Merge lp:~awe/phablet-extras/ofono-raring into lp:phablet-extras/ofono

[Tony Espy]

Re-based ofono/RILD code on new upstream version ofono-1.12-0ubuntu2b1 from Raring.

This MR represents a re-base of the oFono RILD code from the quantal version (ofono-1.9) to the raring version (ofono-1.12).

Basic functional testing was run on a Galaxy Nexus using a recent daily build. Phone calls and SMSs were both tested.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:31
http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-ci/2/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/2
        deb: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/2/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/phablet-extras-ofono-ci/2/rebuild

review: Approve (continuous-integration)

[Ricardo Salveti (rsalveti)]

There are quite a few things missing here:
* Not running autoreconf during configure (as we change configure.ac and makefile.am)
* makefile.am not covering all changes we had (missing -lwaudio for example)
* build fails when building the plugins:
plugins/phonesim.o: In function `localhfp_enable':
/home/phablet/ofono/ofono-raring/plugins/phonesim.c:883: undefined reference to `hfp_slc_info_init'
/home/phablet/ofono/ofono-raring/plugins/phonesim.c:885: undefined reference to `hfp_slc_establish'
plugins/hfp_hf.o: In function `hfp_agent_new_connection':
/home/phablet/ofono/ofono-raring/plugins/hfp_hf.c:173: undefined reference to `hfp_slc_info_init'
plugins/hfp_hf.o: In function `service_level_connection':
/home/phablet/ofono/ofono-raring/plugins/hfp_hf.c:156: undefined reference to `hfp_slc_establish'
collect2: error: ld returned 1 exit status
make[2]: *** [src/ofonod] Error 1
make[1]: *** [all] Error 2
make[1]: Leaving directory `/home/phablet/ofono/ofono-raring'
make: *** [debian/stamp-makefile-build] Error 2
dpkg-buildpackage: error: debian/rules build gave error exit status 2

Trying to build the package with dpkg-buildpackage -uc -us.

review: Needs Fixing

[Ricardo Salveti (rsalveti)]

Needed changes just to make it get to the failed point pointed above:
$ bzr diff
=== modified file 'Makefile.am'
--- Makefile.am 2013-03-28 12:50:26 +0000
+++ Makefile.am 2013-04-09 02:28:20 +0000
@@ -526,7 +526,7 @@
    src/cdma-sms.c src/private-network.c src/cdma-netreg.c \
    src/cdma-provision.c src/handsfree.c

-src_ofonod_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ -ldl
+src_ofonod_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ -ldl -lwaudio

 src_ofonod_LDFLAGS = -Wl,--export-dynamic \
     -Wl,--version-script=$(srcdir)/src/ofono.ver

=== modified file 'debian/control'
--- debian/control 2013-03-28 12:50:26 +0000
+++ debian/control 2013-04-09 02:14:30 +0000
@@ -6,10 +6,12 @@
 Uploaders: Jonny Lamb <email address hidden>, Hector Oron <email address hidden>, Konstantinos Margaritis <email address hidden>
 Build-Depends: debhelper (>= 7.0.50~),
                cdbs,
+ dh-autoreconf,
                libtool,
                libglib2.0-dev (>= 2.22),
                libdbus-glib-1-dev,
                libudev-dev,
+ libwaudio1-dev (>= 1.4~quantal1),
                udev,
                libbluetooth-dev (>= 4.30),
                mobile-broadband-provider-info

=== modified file 'debian/rules'
--- debian/rules 2012-08-22 19:59:08 +0000
+++ debian/rules 2013-04-09 02:05:25 +0000
@@ -2,6 +2,7 @@
 DEB_AUTO_CLEANUP_RCS := yes

 include /usr/share/cdbs/1/class/autotools.mk
+include /usr/share/cdbs/1/rules/autoreconf.mk
 include /usr/share/cdbs/1/rules/debhelper.mk
 #include /usr/share/cdbs/1/rules/simple-patchsys.mk
 include /usr/share/cdbs/1/rules/utils.mk

[lp:~awe/phablet-extras/ofono-raring]

32. By Tony Espy on 2013-04-09

Fix build problems by enabled autoreconf, disabling Bluetooth, and fixing
the android audio system dependency.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:32
http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-ci/4/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/4/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/phablet-extras-ofono-ci/4/rebuild

review: Needs Fixing (continuous-integration)

[lp:~awe/phablet-extras/ofono-raring]

33. By Tony Espy on 2013-04-09

Remove dundee reference in debian/ofono.install.

34. By Tony Espy on 2013-04-09

Removed udev references from debian/ofono.install.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:34
http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-ci/5/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/5
        deb: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/5/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/phablet-extras-ofono-ci/5/rebuild

review: Approve (continuous-integration)

[lp:~awe/phablet-extras/ofono-raring]

35. By Tony Espy on 2013-04-09

Disable udev in debian/rules.

[Tony Espy (awe)]

Should be all set.

I verified the latest branch builds, installs and runs on a quantal touch daily ( today's ). I verified that incoming/outgoing sms and voice calls worked.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:35
http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-ci/6/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/6
        deb: http://jenkins.qa.ubuntu.com/job/phablet-extras-ofono-raring-armhf-ci/6/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/phablet-extras-ofono-ci/6/rebuild

review: Approve (continuous-integration)

[Ricardo Salveti (rsalveti)]

Good, worked fine at both quantal and raring, with phone calls and sms.

Thanks!

review: Approve

=== modified file 'Makefile.am'
--- Makefile.am	2013-01-28 16:25:32 +0000
+++ Makefile.am	2013-04-09 20:01:20 +0000
@@ -89,6 +89,12 @@
 				gisi/server.c gisi/server.h \
 				gisi/socket.c gisi/socket.h
 
+gril_sources = gril/gril.h gril/gril.c gril/grilio.h \
+				gril/grilio.c gril/grilutil.h \
+				gril/grilutil.c gril/ringbuffer.h \
+				gril/gfunc.h gril/ril.h \
+				gril/parcel.c gril/parcel.h
+
 btio_sources = btio/btio.h btio/btio.c
 
 if UDEV
@@ -101,6 +107,25 @@
 builtin_sources += plugins/udevng.c
 endif
 
+if RILMODEM
+builtin_sources += $(gril_sources)
+
+builtin_modules += ril
+builtin_sources += plugins/ril.c
+
+builtin_modules += rilmodem
+builtin_sources += drivers/rilmodem/rilmodem.h \
+			drivers/rilmodem/rilmodem.c \
+			drivers/rilmodem/devinfo.c \
+			drivers/rilmodem/network-registration.c \
+			drivers/rilmodem/voicecall.c \
+			drivers/rilmodem/call-volume.c \
+			drivers/rilmodem/sms.c \
+			drivers/rilmodem/rilutil.c \
+			drivers/rilmodem/rilutil.h
+
+endif
+
 if ISIMODEM
 builtin_modules += isimodem
 builtin_sources += $(gisi_sources) \
@@ -210,7 +235,7 @@
 			drivers/atmodem/gprs-context.c \
 			drivers/atmodem/sim-auth.c \
 			drivers/atmodem/gnss.c
-
+if !RILMODEM
 builtin_modules += nwmodem
 builtin_sources += drivers/atmodem/atutil.h \
 			drivers/nwmodem/nwmodem.h \
@@ -299,6 +324,13 @@
 			drivers/dunmodem/network-registration.c \
 			drivers/dunmodem/gprs.c
 
+builtin_modules += speedupmodem
+builtin_sources += drivers/atmodem/atutil.h \
+			drivers/speedupmodem/speedupmodem.h \
+			drivers/speedupmodem/speedupmodem.c \
+			drivers/speedupmodem/ussd.c
+endif
+
 builtin_modules += hfpmodem
 builtin_sources += drivers/atmodem/atutil.h \
 			drivers/hfpmodem/hfpmodem.h \
@@ -311,12 +343,6 @@
 			drivers/hfpmodem/devinfo.c \
 			drivers/hfpmodem/handsfree.c
 
-builtin_modules += speedupmodem
-builtin_sources += drivers/atmodem/atutil.h \
-			drivers/speedupmodem/speedupmodem.h \
-			drivers/speedupmodem/speedupmodem.c \
-			drivers/speedupmodem/ussd.c
-
 if PHONESIM
 builtin_modules += phonesim
 builtin_sources += plugins/phonesim.c
@@ -335,6 +361,7 @@
 			drivers/cdmamodem/connman.c
 endif
 
+if !RILMODEM
 builtin_modules += g1
 builtin_sources += plugins/g1.c
 
@@ -406,6 +433,7 @@
 
 builtin_modules += sim900
 builtin_sources += plugins/sim900.c
+endif
 
 if BLUETOOTH
 builtin_modules += bluetooth
@@ -498,7 +526,7 @@
 			src/cdma-sms.c src/private-network.c src/cdma-netreg.c \
 			src/cdma-provision.c src/handsfree.c
 
-src_ofonod_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ -ldl
+src_ofonod_LDADD = $(builtin_libadd) @GLIB_LIBS@ @DBUS_LIBS@ -ldl -lwaudio
 
 src_ofonod_LDFLAGS = -Wl,--export-dynamic \
 				-Wl,--version-script=$(srcdir)/src/ofono.ver
@@ -522,7 +550,7 @@
 
 INCLUDES = -I$(builddir)/include -I$(builddir)/src -I$(srcdir)/src \
 			-I$(srcdir)/gdbus -I$(srcdir)/gisi -I$(srcdir)/gatchat \
-			-I$(srcdir)/btio
+			-I$(srcdir)/btio -I$(srcdir)/gril
 
 doc_files = doc/overview.txt doc/ofono-paper.txt doc/release-faq.txt \
 		doc/manager-api.txt doc/modem-api.txt doc/network-api.txt \

=== modified file 'configure.ac'
--- configure.ac	2013-01-28 16:25:32 +0000
+++ configure.ac	2013-04-09 20:01:20 +0000
@@ -167,6 +167,11 @@
 					[enable_isimodem=${enableval}])
 AM_CONDITIONAL(ISIMODEM, test "${enable_isimodem}" != "no")
 
+AC_ARG_ENABLE(rilmodem, AC_HELP_STRING([--disable-rilmodem],
+                                [disable RIL modem support]),
+                                        [enable_rilmodem=${enableval}])
+AM_CONDITIONAL(RILMODEM, test "${enable_rilmodem}" != "no")
+
 AC_ARG_ENABLE(qmimodem, AC_HELP_STRING([--disable-qmimodem],
 				[disable Qualcomm QMI modem support]),
 					[enable_qmimodem=${enableval}])

=== modified file 'debian/changelog'
--- debian/changelog	2013-04-03 16:11:02 +0000
+++ debian/changelog	2013-04-09 20:01:20 +0000
@@ -1,5 +1,61 @@
 ofono (1.12phablet1) UNRELEASED; urgency=low
 
+  [ Ricardo Salveti de Araujo ]
+  * ofono.upstart: not starting with debug by default, not needed anymore
+  * drivers/rilmodem/devinfo.c: fake data should just use Fake instead of
+    Galaxy Nexus
+
+  [ Tony Espy ]
+  * gril/*, plugins/ril.c, drivers/rilmodem/*: fixed copyright headers,
+    sanitized comments.
+
+  [ Ricardo Salveti de Araujo ]
+  * Fixing audio states during and after a call, previously broken with
+    JellyBean (LP: #1101339)
+
+  [ Tony Espy ]
+  * Re-named the galaxynexus plugin to ril.
+  * [galaxynexus] Add SIM checking to modem initialization.
+  * [gril] Add ril_request_id_to_string function.
+  * [core] Modify ofono_modem_set_online() to call modem_change_state(),
+    which triggers our new modem initialization logic in galaxynexus'
+    post_online function.
+
+  [ Ricardo Salveti de Araujo ]
+  * parcel.c: fixing data padding boundary for parcel_w_string (LP: #1088559)
+  * Only setting audio mode in call when actually dialing or answering (to
+    allow ringtones at the ubuntu side)
+
+  [ Tony Espy ]
+  * Disable atmodem plugin on starup.
+
+  [ Ricardo Salveti de Araujo ]
+  * Adding proper support for network registration and network state changes
+  * Support registering for network time update reports
+  * Extending network registration to support current operator, list of
+    operators and auto/manual registration
+  * Enabling support to retrieve the signal strength
+  * Enabling initial support for DTMF
+  * Adding support for answering a call
+  * Tuning start sleep for 8 and running with debug messages enabled
+  * Sync ril_delayed_register timeout to 2 for all services in rilmodem
+  * Setting up voice state and enabling voice call support at AudioFlinger
+
+  [ Tony Espy ]
+  * Initial version of notification framework for RIL
+    unsolicited events ( signal strength, new sms, ... ).
+  * Support for incoming SMS messages (LP: #1085896).
+
+  [ Ricardo Salveti de Araujo ]
+  * Adding support for voice call (LP: #1085893)
+  * Adding utils files for parcel and string handling
+  * Enable basic support for voice volume (mute/unmute)
+
+  [ Michael Frey ]
+  * debian/ofono.upstart: Fix for hang on shutdown.
+
+  [ Tony Espy ]
+  * First hard-coded support for RIL modem on Galaxy Nexus.
   * Initial phablet version, converted to native for
     easier development of new RIL driver/plugin code.
     - debian/source/format: changed to 3.0 (native)

=== modified file 'debian/control'
--- debian/control	2012-08-22 19:59:08 +0000
+++ debian/control	2013-04-09 20:01:20 +0000
@@ -6,9 +6,12 @@
 Uploaders: Jonny Lamb <[e-mail]>, Hector Oron <[e-mail]>, Konstantinos Margaritis <[e-mail]>
 Build-Depends: debhelper (>= 7.0.50~),
                cdbs,
+               dh-autoreconf,
+               libtool,
                libglib2.0-dev (>= 2.22),
                libdbus-glib-1-dev,
                libudev-dev,
+               libwaudio1-dev,
                udev,
                libbluetooth-dev (>= 4.30),
                mobile-broadband-provider-info

=== modified file 'debian/ofono.install'
--- debian/ofono.install	2012-08-22 19:59:08 +0000
+++ debian/ofono.install	2013-04-09 20:01:20 +0000
@@ -1,6 +1,4 @@
 debian/tmp/etc/dbus-1/system.d/*
 debian/tmp/usr/sbin/ofonod
-debian/tmp/usr/sbin/dundee
 debian/tmp/etc/ofono
-debian/tmp/lib/udev/rules.d/*
 debian/tmp/usr/share/man

=== modified file 'debian/ofono.upstart'
--- debian/ofono.upstart	2010-09-02 18:21:57 +0000
+++ debian/ofono.upstart	2013-04-09 20:01:20 +0000
@@ -6,4 +6,9 @@
 expect fork
 respawn
 
-exec ofonod
+exec ofonod --noplugin=atmodem
+
+pre-start script
+  sleep 8
+end script
+

=== modified file 'debian/rules'
--- debian/rules	2012-08-22 19:59:08 +0000
+++ debian/rules	2013-04-09 20:01:20 +0000
@@ -2,14 +2,14 @@
 DEB_AUTO_CLEANUP_RCS := yes
 
 include /usr/share/cdbs/1/class/autotools.mk
+include /usr/share/cdbs/1/rules/autoreconf.mk
 include /usr/share/cdbs/1/rules/debhelper.mk
-#include /usr/share/cdbs/1/rules/simple-patchsys.mk
 include /usr/share/cdbs/1/rules/utils.mk
 
 DEB_DH_INSTALLINIT_ARGS := --no-restart-on-upgrade
 
 common-binary-post-install-arch:: list-missing
 
-DEB_CONFIGURE_EXTRA_FLAGS := --enable-bluetooth --enable-dundee
+DEB_CONFIGURE_EXTRA_FLAGS := --disable-bluetooth --disable-dundee --disable-udev
 
 include $(CURDIR)/debian/update-patches.mk

=== added directory 'drivers/rilmodem'
=== added file 'drivers/rilmodem/call-volume.c'
--- drivers/rilmodem/call-volume.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/call-volume.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,186 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 <string.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/call-volume.h>
+
+#include "gril.h"
+#include "grilutil.h"
+
+#include "common.h"
+
+#include "rilmodem.h"
+#include "parcel.h"
+
+struct cv_data {
+	GRil *ril;
+	unsigned int vendor;
+};
+
+static void volume_mute_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_call_volume_cb_t cb = cbd->cb;
+	struct ofono_error error;
+
+	DBG("");
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		ofono_error("Could not set the ril mute state");
+		decode_ril_error(&error, "FAIL");
+	}
+
+	cb(&error, cbd->data);
+}
+
+static void ril_call_volume_mute(struct ofono_call_volume *cv, int muted,
+				ofono_call_volume_cb_t cb, void *data)
+{
+	struct cv_data *cvd = ofono_call_volume_get_data(cv);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct parcel rilp;
+
+	DBG("");
+
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, 1);
+	parcel_w_int32(&rilp, muted);
+	g_ril_send(cvd->ril, RIL_REQUEST_SET_MUTE, rilp.data,
+			rilp.size, volume_mute_cb, cbd, g_free);
+	parcel_free(&rilp);
+
+	return;
+}
+
+static void probe_mute_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_call_volume *cv = user_data;
+	struct parcel rilp;
+	int muted;
+
+	DBG("");
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("Could not retrive the ril mute state");
+		return;
+	}
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	muted = parcel_r_int32(&rilp);
+	DBG("Initial ril muted state: %d", muted);
+
+	ofono_call_volume_set_muted(cv, muted);
+}
+
+static void call_probe_mute(gpointer user_data)
+{
+	struct ofono_call_volume *cv = user_data;
+	struct cv_data *cvd = ofono_call_volume_get_data(cv);
+
+	DBG("Requesting mute from RIL");
+
+	g_ril_send(cvd->ril, RIL_REQUEST_GET_MUTE, NULL, 0,
+				probe_mute_cb, cv, NULL);
+
+	return;
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_call_volume *cv = user_data;
+	DBG("");
+	ofono_call_volume_register(cv);
+
+	/* Probe the mute state */
+	call_probe_mute(user_data);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_call_volume_probe(struct ofono_call_volume *cv,
+				unsigned int vendor, void *data)
+{
+	GRil *ril = data;
+	struct cv_data *cvd;
+
+	DBG("");
+
+	cvd = g_new0(struct cv_data, 1);
+	if (cvd == NULL)
+		return -ENOMEM;
+
+	cvd->ril = g_ril_clone(ril);
+	cvd->vendor = vendor;
+
+	ofono_call_volume_set_data(cv, cvd);
+
+	g_timeout_add_seconds(2, ril_delayed_register, cv);
+
+	return 0;
+}
+
+static void ril_call_volume_remove(struct ofono_call_volume *cv)
+{
+	struct cv_data *cvd = ofono_call_volume_get_data(cv);
+
+	ofono_call_volume_set_data(cv, NULL);
+
+	g_ril_unref(cvd->ril);
+	g_free(cvd);
+}
+
+static struct ofono_call_volume_driver driver = {
+	.name = "rilmodem",
+	.probe = ril_call_volume_probe,
+	.remove = ril_call_volume_remove,
+	.mute = ril_call_volume_mute,
+};
+
+void ril_call_volume_init(void)
+{
+	ofono_call_volume_driver_register(&driver);
+}
+
+void ril_call_volume_exit(void)
+{
+	ofono_call_volume_driver_unregister(&driver);
+}

=== added file 'drivers/rilmodem/devinfo.c'
--- drivers/rilmodem/devinfo.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/devinfo.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,171 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/devinfo.h>
+
+#include "gril.h"
+
+#include "rilmodem.h"
+
+/*
+ * TODO: The functions in this file are stubbed out, and
+ * will need to be re-worked to talk to the /gril layer
+ * in order to get real values from RILD.
+ */
+
+static void ril_query_manufacturer(struct ofono_devinfo *info,
+					ofono_devinfo_query_cb_t cb,
+					void *data)
+{
+	const char *attr = "Fake Manufacturer";
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct ofono_error error;
+	decode_ril_error(&error, "OK");
+
+	cb(&error, attr, cbd->data);
+
+	/* Note: this will need to change if cbd passed to gril layer */
+	g_free(cbd);
+}
+
+static void ril_query_model(struct ofono_devinfo *info,
+				ofono_devinfo_query_cb_t cb,
+				void *data)
+{
+	const char *attr = "Fake Modem Model";
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct ofono_error error;
+	decode_ril_error(&error, "OK");
+
+	cb(&error, attr, cbd->data);
+
+	/* Note: this will need to change if cbd passed to gril layer */
+	g_free(cbd);
+}
+
+static void ril_query_revision(struct ofono_devinfo *info,
+				ofono_devinfo_query_cb_t cb,
+				void *data)
+{
+	const char *attr = "Fake Revision";
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct ofono_error error;
+	decode_ril_error(&error, "OK");
+
+	cb(&error, attr, cbd->data);
+
+	/* Note: this will need to change if cbd passed to gril layer */
+	g_free(cbd);
+}
+
+static void ril_query_serial(struct ofono_devinfo *info,
+				ofono_devinfo_query_cb_t cb,
+				void *data)
+{
+	const char *attr = "THIS-IS-A-FAKE-SERIAL-NO";
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct ofono_error error;
+	decode_ril_error(&error, "OK");
+
+	cb(&error, attr, cbd->data);
+
+	/* Note: this will need to change if cbd passed to gril layer */
+	g_free(cbd);
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_devinfo *info = user_data;
+	DBG("");
+	ofono_devinfo_register(info);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_devinfo_probe(struct ofono_devinfo *info, unsigned int vendor,
+				void *data)
+{
+	GRil *ril = NULL;
+
+	if (data != NULL)
+		ril = g_ril_clone(data);
+
+	ofono_devinfo_set_data(info, ril);
+
+	DBG("");
+
+        /* Nothing to send...
+	 *
+	 * ofono_devinfo_register() needs to be called after
+	 * the driver has been set in devinfo_create() which
+	 * calls this function.  Most other drivers use a 
+	 * callback after getting some return from the modem
+	 * itself...
+	 */
+        g_timeout_add_seconds(1, ril_delayed_register, info);
+
+	return 0;
+}
+
+static void ril_devinfo_remove(struct ofono_devinfo *info)
+{
+	GRil *ril = ofono_devinfo_get_data(info);
+
+	ofono_devinfo_set_data(info, NULL);
+
+	g_ril_unref(ril);
+}
+
+static struct ofono_devinfo_driver driver = {
+	.name			= "rilmodem",
+	.probe			= ril_devinfo_probe,
+	.remove			= ril_devinfo_remove,
+	.query_manufacturer	= ril_query_manufacturer,
+	.query_model		= ril_query_model,
+	.query_revision		= ril_query_revision,
+	.query_serial		= ril_query_serial
+};
+
+void ril_devinfo_init(void)
+{
+	ofono_devinfo_driver_register(&driver);
+}
+
+void ril_devinfo_exit(void)
+{
+	ofono_devinfo_driver_unregister(&driver);
+}

=== added file 'drivers/rilmodem/network-registration.c'
--- drivers/rilmodem/network-registration.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/network-registration.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,595 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2010  ST-Ericsson AB.
+ *  Copyright (C) 2012  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 <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <glib.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/netreg.h>
+
+#include "gril.h"
+
+#include "rilmodem.h"
+#include "parcel.h"
+#include "common.h"
+#include "parcel.h"
+
+struct netreg_data {
+	GRil *ril;
+	char mcc[OFONO_MAX_MCC_LENGTH + 1];
+	char mnc[OFONO_MAX_MNC_LENGTH + 1];
+	int signal_index; /* If strength is reported via CIND */
+	int signal_min; /* min strength reported via CIND */
+	int signal_max; /* max strength reported via CIND */
+	int signal_invalid; /* invalid strength reported via CIND */
+	int tech;
+	struct ofono_network_time time;
+	guint nitz_timeout;
+	unsigned int vendor;
+};
+
+/* 27.007 Section 7.3 <stat> */
+enum operator_status {
+	OPERATOR_STATUS_UNKNOWN =	0,
+	OPERATOR_STATUS_AVAILABLE =	1,
+	OPERATOR_STATUS_CURRENT =	2,
+	OPERATOR_STATUS_FORBIDDEN =	3,
+};
+
+static void extract_mcc_mnc(const char *str, char *mcc, char *mnc)
+{
+	/* Three digit country code */
+	strncpy(mcc, str, OFONO_MAX_MCC_LENGTH);
+	mcc[OFONO_MAX_MCC_LENGTH] = '\0';
+
+	/* Usually a 2 but sometimes 3 digit network code */
+	strncpy(mnc, str + OFONO_MAX_MCC_LENGTH, OFONO_MAX_MNC_LENGTH);
+	mnc[OFONO_MAX_MNC_LENGTH] = '\0';
+}
+
+/*
+ * TODO: The functions in this file are stubbed out, and
+ * will need to be re-worked to talk to the /gril layer
+ * in order to get real values from RILD.
+ */
+
+static void ril_creg_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_netreg_status_cb_t cb = cbd->cb;
+	struct netreg_data *nd = cbd->user;
+	struct ofono_error error;
+	int status, lac, ci, tech;
+
+	DBG("");
+
+	if (message->error != RIL_E_SUCCESS) {
+		decode_ril_error(&error, "FAIL");
+		ofono_error("Failed to pull registration state");
+		cb(&error, -1, -1, -1, -1, cbd->data);
+		return;
+	}
+
+	decode_ril_error(&error, "OK");
+
+	if (ril_util_parse_reg(message, &status,
+				&lac, &ci, &tech) == FALSE) {
+		CALLBACK_WITH_FAILURE(cb, -1, -1, -1, -1, cbd->data);
+		return;
+	}
+
+	DBG("oFono reg - status: %s, lac: %x, ci: %x, tech: %s",
+			registration_status_to_string(status),
+			lac, ci,
+			registration_tech_to_string(tech));
+
+	nd->tech = tech;
+	cb(&error, status, lac, ci, tech, cbd->data);
+}
+
+static void ril_creg_notify(struct ofono_error *error, int status, int lac,
+					int ci, int tech, gpointer user_data)
+{
+	struct ofono_netreg *netreg = user_data;
+
+	DBG("");
+
+        if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+                DBG("Error during status notification");
+                return;
+        }
+
+	ofono_netreg_status_notify(netreg, status, lac, ci, tech);
+}
+
+static void ril_network_state_change(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_netreg *netreg = user_data;
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(ril_creg_notify, netreg);
+
+	DBG("");
+
+	cbd->user = nd;
+
+	if (message->req != RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED)
+		goto error;
+
+	if (g_ril_send(nd->ril, RIL_REQUEST_VOICE_REGISTRATION_STATE, NULL,
+			0, ril_creg_cb, cbd, g_free) > 0)
+		return;
+
+	/* For operator update ofono will use the current_operator cb
+	 * so we don't need to probe ril here */
+
+error:
+	g_free(cbd);
+
+	ofono_error("Unable to request network state changed");
+}
+
+static void ril_registration_status(struct ofono_netreg *netreg,
+					ofono_netreg_status_cb_t cb,
+					void *data)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	cbd->user = nd;
+
+	if (g_ril_send(nd->ril, RIL_REQUEST_VOICE_REGISTRATION_STATE, NULL,
+			0, ril_creg_cb, cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, -1, -1, -1, -1, data);
+}
+
+static void ril_cops_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_netreg_operator_cb_t cb = cbd->cb;
+	struct netreg_data *nd = cbd->user;
+	struct ofono_error error;
+	struct parcel rilp;
+	struct ofono_network_operator op;
+	gchar *lalpha, *salpha, *numeric;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		ofono_error("Failed to retrive the current operator");
+		goto error;
+	}
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	/* Size of char ** */
+	if (parcel_r_int32(&rilp) == 0)
+		goto error;
+
+	lalpha = parcel_r_string(&rilp);
+	salpha = parcel_r_string(&rilp);
+	numeric = parcel_r_string(&rilp);
+
+	DBG("RIL cops - lalpha: %s, salpha: %s, numeric: %s",
+			lalpha, salpha, numeric);
+
+	/* Try to use long by default */
+	if (lalpha)
+		strncpy(op.name, lalpha, OFONO_MAX_OPERATOR_NAME_LENGTH);
+	else
+		strncpy(op.name, salpha, OFONO_MAX_OPERATOR_NAME_LENGTH);
+
+	extract_mcc_mnc(numeric, op.mcc, op.mnc);
+
+	/* Set to current */
+	op.status = OPERATOR_STATUS_CURRENT;
+	op.tech = nd->tech;
+
+	DBG("ril_cops_cb: %s, %s, %s, %s", op.name, op.mcc, op.mnc,
+			registration_tech_to_string(op.tech));
+
+	g_free(lalpha);
+	g_free(salpha);
+	g_free(numeric);
+
+	cb(&error, &op, cbd->data);
+
+	return;
+
+error:
+	CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);
+}
+
+static void ril_current_operator(struct ofono_netreg *netreg,
+				ofono_netreg_operator_cb_t cb, void *data)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	cbd->user = nd;
+
+	if (g_ril_send(nd->ril, RIL_REQUEST_OPERATOR, NULL,
+			0, ril_cops_cb, cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, NULL, data);
+}
+
+static void ril_cops_list_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_netreg_operator_list_cb_t cb = cbd->cb;
+	struct ofono_network_operator *list;
+	struct ofono_error error;
+	struct parcel rilp;
+	int noperators, i;
+	gchar *lalpha, *salpha, *numeric, *status;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		ofono_error("Failed to retrive the list of operators");
+		goto error;
+	}
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	/* Number of operators at the list (4 strings for every operator) */
+	noperators = parcel_r_int32(&rilp) / 4;
+	DBG("noperators = %d", noperators);
+
+	list = g_try_new0(struct ofono_network_operator, noperators);
+	if (list == NULL)
+		goto error;
+
+	for (i = 0; i < noperators; i++) {
+		lalpha = parcel_r_string(&rilp);
+		salpha = parcel_r_string(&rilp);
+		numeric = parcel_r_string(&rilp);
+		status = parcel_r_string(&rilp);
+
+		/* Try to use long by default */
+		if (lalpha) {
+			strncpy(list[i].name, lalpha,
+					OFONO_MAX_OPERATOR_NAME_LENGTH);
+		} else {
+			strncpy(list[i].name, salpha,
+					OFONO_MAX_OPERATOR_NAME_LENGTH);
+		}
+
+		extract_mcc_mnc(numeric, list[i].mcc, list[i].mnc);
+
+		/* Use GSM as default, as RIL doesn't pass that info to us */
+		list[i].tech = ACCESS_TECHNOLOGY_GSM;
+
+		/* Set the proper status  */
+		if (!strcmp(status, "unknown"))
+			list[i].status = OPERATOR_STATUS_UNKNOWN;
+		else if (!strcmp(status, "available"))
+			list[i].status = OPERATOR_STATUS_AVAILABLE;
+		else if (!strcmp(status, "current"))
+			list[i].status = OPERATOR_STATUS_CURRENT;
+		else if (!strcmp(status, "forbidden"))
+			list[i].status = OPERATOR_STATUS_FORBIDDEN;
+
+		DBG("Operator: %s, %s, %s, status: %s",
+				list[i].name, list[i].mcc,
+				list[i].mnc, status);
+
+		g_free(lalpha);
+		g_free(salpha);
+		g_free(numeric);
+		g_free(status);
+	}
+
+	cb(&error, noperators, list, cbd->data);
+
+	return;
+
+error:
+	CALLBACK_WITH_FAILURE(cb, 0, NULL, cbd->data);
+}
+
+static void ril_list_operators(struct ofono_netreg *netreg,
+				ofono_netreg_operator_list_cb_t cb, void *data)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	cbd->user = nd;
+
+	if (g_ril_send(nd->ril, RIL_REQUEST_QUERY_AVAILABLE_NETWORKS, NULL,
+			0, ril_cops_list_cb, cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, 0, NULL, data);
+}
+
+static void ril_register_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_netreg_register_cb_t cb = cbd->cb;
+	struct ofono_error error;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		decode_ril_error(&error, "FAIL");
+	}
+
+	cb(&error, cbd->data);
+}
+
+static void ril_register_auto(struct ofono_netreg *netreg,
+				ofono_netreg_register_cb_t cb, void *data)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	if (g_ril_send(nd->ril, RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC,
+			NULL, 0, ril_register_cb, cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, data);
+}
+
+static void ril_register_manual(struct ofono_netreg *netreg,
+				const char *mcc, const char *mnc,
+				ofono_netreg_register_cb_t cb, void *data)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	char buf[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1];
+	struct parcel rilp;
+	int ret;
+
+	parcel_init(&rilp);
+
+	/* RIL expects a char * specifying MCCMNC of network to select */
+	snprintf(buf, sizeof(buf), "%s%s", mcc, mnc);
+	parcel_w_string(&rilp, buf);
+
+	ret = g_ril_send(nd->ril, RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL,
+				rilp.data, rilp.size, ril_register_cb,
+				cbd, g_free);
+	parcel_free(&rilp);
+
+	/* In case of error free cbd and return the cb with failure */
+	if (ret <= 0) {
+		g_free(cbd);
+		CALLBACK_WITH_FAILURE(cb, data);
+	}
+}
+
+static void ril_strength_notify(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_netreg *netreg = user_data;
+	int strength;
+
+	g_assert(message->req == RIL_UNSOL_SIGNAL_STRENGTH);
+
+	strength = ril_util_get_signal(message);
+	ofono_netreg_strength_notify(netreg, strength);
+
+	return;
+}
+
+static void ril_strength_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_netreg_strength_cb_t cb = cbd->cb;
+	struct ofono_error error;
+	int strength;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		ofono_error("Failed to retrive the signal strength");
+		goto error;
+	}
+
+	strength = ril_util_get_signal(message);
+	cb(&error, strength, cbd->data);
+
+	return;
+
+error:
+	CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
+}
+
+static void ril_signal_strength(struct ofono_netreg *netreg,
+				ofono_netreg_strength_cb_t cb, void *data)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct cb_data *cbd = cb_data_new(cb, data);
+
+	cbd->user = nd;
+
+	if (g_ril_send(nd->ril, RIL_REQUEST_SIGNAL_STRENGTH,
+			NULL, 0, ril_strength_cb, cbd, g_free) > 0)
+		return;
+
+	g_free(cbd);
+
+	CALLBACK_WITH_FAILURE(cb, -1, data);
+}
+
+static void ril_nitz_notify(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_netreg *netreg = user_data;
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	struct parcel rilp;
+	int year, mon, mday, hour, min, sec, dst, tzi;
+	char tzs, tz[4];
+	gchar *nitz;
+
+	if (message->req != RIL_UNSOL_NITZ_TIME_RECEIVED)
+		goto error;
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	nitz = parcel_r_string(&rilp);
+
+	DBG("RIL NITZ: %s", nitz);
+
+	sscanf(nitz, "%u/%u/%u,%u:%u:%u%c%u,%u", &year, &mon, &mday,
+			&hour, &min, &sec, &tzs, &tzi, &dst);
+	sprintf(tz, "%c%d", tzs, tzi);
+
+	nd->time.utcoff = atoi(tz) * 15 * 60;
+	nd->time.dst = dst;
+	nd->time.sec = sec;
+	nd->time.min = min;
+	nd->time.hour = hour;
+	nd->time.mday = mday;
+	nd->time.mon = mon;
+	nd->time.year = 2000 + year;
+
+	ofono_netreg_time_notify(netreg, &nd->time);
+
+	g_free(nitz);
+
+	return;
+
+error:
+	ofono_error("Unable to notify ofono about nitz");
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_netreg *netreg = user_data;
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+	ofono_netreg_register(netreg);
+
+	/* Register for network state changes */
+	g_ril_register(nd->ril, RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED,
+			ril_network_state_change, netreg);
+
+	/* Register for network time update reports */
+	g_ril_register(nd->ril, RIL_UNSOL_NITZ_TIME_RECEIVED,
+			ril_nitz_notify, netreg);
+
+	/* Register for signal strength changes */
+	g_ril_register(nd->ril, RIL_UNSOL_SIGNAL_STRENGTH,
+			ril_strength_notify, netreg);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
+				void *data)
+{
+	GRil *ril = data;
+	struct netreg_data *nd;
+
+	nd = g_new0(struct netreg_data, 1);
+
+	nd->ril = g_ril_clone(ril);
+	nd->vendor = vendor;
+	nd->tech = -1;
+	nd->time.sec = -1;
+	nd->time.min = -1;
+	nd->time.hour = -1;
+	nd->time.mday = -1;
+	nd->time.mon = -1;
+	nd->time.year = -1;
+	nd->time.dst = 0;
+	nd->time.utcoff = 0;
+	ofono_netreg_set_data(netreg, nd);
+
+        /* ofono_netreg_register() needs to be called after
+	 * the driver has been set in devinfo_create() which
+	 * calls this function.  Most other drivers use a 
+	 * callback after getting some return from the modem
+	 * itself...
+	 */
+        g_timeout_add_seconds(1, ril_delayed_register, netreg);
+
+	return 0;
+}
+
+static void ril_netreg_remove(struct ofono_netreg *netreg)
+{
+	struct netreg_data *nd = ofono_netreg_get_data(netreg);
+
+	if (nd->nitz_timeout)
+		g_source_remove(nd->nitz_timeout);
+
+	ofono_netreg_set_data(netreg, NULL);
+
+	g_ril_unref(nd->ril);
+	g_free(nd);
+}
+
+static struct ofono_netreg_driver driver = {
+	.name				= "rilmodem",
+	.probe				= ril_netreg_probe,
+	.remove				= ril_netreg_remove,
+	.registration_status		= ril_registration_status,
+	.current_operator		= ril_current_operator,
+	.list_operators			= ril_list_operators,
+	.register_auto			= ril_register_auto,
+	.register_manual		= ril_register_manual,
+	.strength			= ril_signal_strength,
+};
+
+void ril_netreg_init(void)
+{
+	ofono_netreg_driver_register(&driver);
+}
+
+void ril_netreg_exit(void)
+{
+	ofono_netreg_driver_unregister(&driver);
+}

=== added file 'drivers/rilmodem/rilmodem.c'
--- drivers/rilmodem/rilmodem.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/rilmodem.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,61 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 <glib.h>
+#include <gril.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/log.h>
+
+#include "rilmodem.h"
+
+static int rilmodem_init(void)
+{
+	DBG("");
+
+	ril_devinfo_init();
+	ril_voicecall_init();
+	ril_sms_init();
+	ril_netreg_init();
+	ril_call_volume_init();
+
+	return 0;
+}
+
+static void rilmodem_exit(void)
+{
+	DBG("");
+
+	ril_devinfo_exit();
+	ril_voicecall_exit();
+	ril_sms_exit();
+	ril_netreg_exit();
+	ril_call_volume_exit();
+}
+
+OFONO_PLUGIN_DEFINE(rilmodem, "RIL modem driver", VERSION,
+		OFONO_PLUGIN_PRIORITY_DEFAULT, rilmodem_init, rilmodem_exit)

=== added file 'drivers/rilmodem/rilmodem.h'
--- drivers/rilmodem/rilmodem.h	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/rilmodem.h	2013-04-09 20:01:20 +0000
@@ -0,0 +1,38 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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
+ *
+ */
+
+#include "rilutil.h"
+
+extern void ril_devinfo_init(void);
+extern void ril_devinfo_exit(void);
+
+extern void ril_call_volume_init(void);
+extern void ril_call_volume_exit(void);
+
+extern void ril_voicecall_init(void);
+extern void ril_voicecall_exit(void);
+
+extern void ril_sms_init(void);
+extern void ril_sms_exit(void);
+
+extern void ril_netreg_init(void);
+extern void ril_netreg_exit(void);

=== added file 'drivers/rilmodem/rilutil.c'
--- drivers/rilmodem/rilutil.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/rilutil.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,372 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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 <glib.h>
+#include <gril.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/log.h>
+#include <ofono/types.h>
+
+#include "common.h"
+#include "rilutil.h"
+#include "parcel.h"
+
+struct ril_util_sim_state_query {
+	GRil *ril;
+	guint cpin_poll_source;
+	guint cpin_poll_count;
+	guint interval;
+	guint num_times;
+	ril_util_sim_inserted_cb_t cb;
+	void *userdata;
+	GDestroyNotify destroy;
+};
+
+static gboolean cpin_check(gpointer userdata);
+
+void decode_ril_error(struct ofono_error *error, const char *final)
+{
+	if (!strcmp(final, "OK")) {
+		error->type = OFONO_ERROR_TYPE_NO_ERROR;
+		error->error = 0;
+	} else {
+		error->type = OFONO_ERROR_TYPE_FAILURE;
+		error->error = 0;
+	}
+}
+
+gint ril_util_call_compare_by_status(gconstpointer a, gconstpointer b)
+{
+	const struct ofono_call *call = a;
+	int status = GPOINTER_TO_INT(b);
+
+	if (status != call->status)
+		return 1;
+
+	return 0;
+}
+
+gint ril_util_call_compare_by_phone_number(gconstpointer a, gconstpointer b)
+{
+	const struct ofono_call *call = a;
+	const struct ofono_phone_number *pb = b;
+
+	return memcmp(&call->phone_number, pb,
+				sizeof(struct ofono_phone_number));
+}
+
+gint ril_util_call_compare_by_id(gconstpointer a, gconstpointer b)
+{
+	const struct ofono_call *call = a;
+	unsigned int id = GPOINTER_TO_UINT(b);
+
+	if (id < call->id)
+		return -1;
+
+	if (id > call->id)
+		return 1;
+
+	return 0;
+}
+
+gint ril_util_call_compare(gconstpointer a, gconstpointer b)
+{
+	const struct ofono_call *ca = a;
+	const struct ofono_call *cb = b;
+
+	if (ca->id < cb->id)
+		return -1;
+
+	if (ca->id > cb->id)
+		return 1;
+
+	return 0;
+}
+
+static gboolean cpin_check(gpointer userdata)
+{
+	struct ril_util_sim_state_query *req = userdata;
+
+	req->cpin_poll_source = 0;
+
+	return FALSE;
+}
+
+struct ril_util_sim_state_query *ril_util_sim_state_query_new(GRil *ril,
+						guint interval, guint num_times,
+						ril_util_sim_inserted_cb_t cb,
+						void *userdata,
+						GDestroyNotify destroy)
+{
+	struct ril_util_sim_state_query *req;
+
+	req = g_new0(struct ril_util_sim_state_query, 1);
+
+	req->ril = ril;
+	req->interval = interval;
+	req->num_times = num_times;
+	req->cb = cb;
+	req->userdata = userdata;
+	req->destroy = destroy;
+
+	cpin_check(req);
+
+	return req;
+}
+
+void ril_util_sim_state_query_free(struct ril_util_sim_state_query *req)
+{
+	if (req == NULL)
+		return;
+
+	if (req->cpin_poll_source > 0)
+		g_source_remove(req->cpin_poll_source);
+
+	if (req->destroy)
+		req->destroy(req->userdata);
+
+	g_free(req);
+}
+
+GSList *ril_util_parse_clcc(struct ril_msg *message)
+{
+	struct ofono_call *call;
+	struct parcel rilp;
+	GSList *l = NULL;
+	int num, i;
+	gchar *number, *name;
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	/* Number of RIL_Call structs */
+	num = parcel_r_int32(&rilp);
+	for (i = 0; i < num; i++) {
+		call = g_try_new(struct ofono_call, 1);
+		if (call == NULL)
+			break;
+
+		ofono_call_init(call);
+		call->status = parcel_r_int32(&rilp);
+		call->id = parcel_r_int32(&rilp);
+		call->phone_number.type = parcel_r_int32(&rilp);
+		parcel_r_int32(&rilp); /* isMpty */
+		parcel_r_int32(&rilp); /* isMT */
+		parcel_r_int32(&rilp); /* als */
+		call->type = parcel_r_int32(&rilp); /* isVoice */
+		parcel_r_int32(&rilp); /* isVoicePrivacy */
+		number = parcel_r_string(&rilp);
+		if (number) {
+			strncpy(call->phone_number.number, number,
+				OFONO_MAX_PHONE_NUMBER_LENGTH);
+			g_free(number);
+		}
+		parcel_r_int32(&rilp); /* numberPresentation */
+		name = parcel_r_string(&rilp);
+		if (name) {
+			strncpy(call->name, name,
+				OFONO_MAX_CALLER_NAME_LENGTH);
+			g_free(name);
+		}
+		parcel_r_int32(&rilp); /* namePresentation */
+		parcel_r_int32(&rilp); /* uusInfo */
+
+		if (strlen(call->phone_number.number) > 0)
+			call->clip_validity = 0;
+		else
+			call->clip_validity = 2;
+
+		DBG("Adding call - id: %d, status: %d, type: %d, number: %s, name: %s",
+				call->id, call->status, call->type,
+				call->phone_number.number, call->name);
+
+		l = g_slist_insert_sorted(l, call, ril_util_call_compare);
+	}
+
+	return l;
+}
+
+gboolean ril_util_parse_reg(struct ril_msg *message, int *status,
+				int *lac, int *ci, int *tech)
+{
+	struct parcel rilp;
+	gchar *sstatus, *slac, *sci, *stech;
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	/* Size of char ** */
+	if (parcel_r_int32(&rilp) == 0)
+		return FALSE;
+
+	sstatus = parcel_r_string(&rilp);
+	slac = parcel_r_string(&rilp);
+	sci = parcel_r_string(&rilp);
+	stech = parcel_r_string(&rilp);
+
+	DBG("RIL reg - status: %s, lac: %s, ci: %s, radio tech: %s",
+				sstatus, slac, sci, stech);
+
+	if (status)
+		*status = atoi(sstatus);
+	if (lac) {
+		if (slac)
+			*lac = strtol(slac, NULL, 16);
+		else
+			*lac = -1;
+	}
+	if (ci) {
+		if (sci)
+			*ci = strtol(sci, NULL, 16);
+		else
+			*ci = -1;
+	}
+	if (tech) {
+		switch(atoi(stech)) {
+		case RADIO_TECH_UNKNOWN:
+			*tech = -1;
+			break;
+		case RADIO_TECH_GPRS:
+			*tech = ACCESS_TECHNOLOGY_GSM;
+			break;
+		case RADIO_TECH_EDGE:
+			*tech = ACCESS_TECHNOLOGY_GSM_EGPRS;
+			break;
+		case RADIO_TECH_UMTS:
+			*tech = ACCESS_TECHNOLOGY_UTRAN;
+			break;
+		case RADIO_TECH_HSDPA:
+			*tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA;
+			break;
+		case RADIO_TECH_HSUPA:
+			*tech = ACCESS_TECHNOLOGY_UTRAN_HSUPA;
+			break;
+		case RADIO_TECH_HSPA:
+			*tech = ACCESS_TECHNOLOGY_UTRAN_HSDPA_HSUPA;
+			break;
+		default:
+			*tech = -1;
+		}
+	}
+
+	/* Free our parcel handlers */
+	g_free(sstatus);
+	g_free(slac);
+	g_free(sci);
+	g_free(stech);
+
+	return TRUE;
+}
+
+gint ril_util_parse_sms_response(struct ril_msg *message)
+{
+	struct parcel rilp;
+	int error, mr;
+	char *ack_pdu;
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	/* TP-Message-Reference for GSM/
+	 * BearerData MessageId for CDMA
+	 */
+	mr = parcel_r_int32(&rilp);
+	ack_pdu = parcel_r_int32(&rilp);
+	error = parcel_r_int32(&rilp);
+
+	DBG("SMS_Response mr: %d, ackPDU: %d, error: %d",
+		mr, ack_pdu, error);
+
+	return mr;
+}
+
+gint ril_util_get_signal(struct ril_msg *message)
+{
+	struct parcel rilp;
+	int gw_signal, cdma_dbm, evdo_dbm, lte_signal;
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	/* RIL_SignalStrength_v6 */
+	/* GW_SignalStrength */
+	gw_signal = parcel_r_int32(&rilp);
+	parcel_r_int32(&rilp); /* bitErrorRate */
+
+	/* CDMA_SignalStrength */
+	cdma_dbm = parcel_r_int32(&rilp);
+	parcel_r_int32(&rilp); /* ecio */
+
+	/* EVDO_SignalStrength */
+	evdo_dbm = parcel_r_int32(&rilp);
+	parcel_r_int32(&rilp); /* ecio */
+	parcel_r_int32(&rilp); /* signalNoiseRatio */
+
+	/* LTE_SignalStrength */
+	lte_signal = parcel_r_int32(&rilp);
+	parcel_r_int32(&rilp); /* rsrp */
+	parcel_r_int32(&rilp); /* rsrq */
+	parcel_r_int32(&rilp); /* rssnr */
+	parcel_r_int32(&rilp); /* cqi */
+
+	DBG("RIL SignalStrength - gw: %d, cdma: %d, evdo: %d, lte: %d",
+			gw_signal, cdma_dbm, evdo_dbm, lte_signal);
+
+	/* Return the first valid one */
+	if ((gw_signal != 99) && (gw_signal != -1))
+		return (gw_signal * 100) / 31;
+	if ((lte_signal != 99) && (lte_signal != -1))
+		return (lte_signal * 100) / 31;
+
+	/* In case of dbm, return the value directly */
+	if (cdma_dbm != -1) {
+		if (cdma_dbm > 100)
+			cdma_dbm = 100;
+		return cdma_dbm;
+	}
+	if (evdo_dbm != -1) {
+		if (evdo_dbm > 100)
+			evdo_dbm = 100;
+		return evdo_dbm;
+	}
+
+	return -1;
+}

=== added file 'drivers/rilmodem/rilutil.h'
--- drivers/rilmodem/rilutil.h	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/rilutil.h	2013-04-09 20:01:20 +0000
@@ -0,0 +1,125 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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
+ *
+ */
+
+enum ril_util_sms_store {
+	RIL_UTIL_SMS_STORE_SM =	0,
+	RIL_UTIL_SMS_STORE_ME =	1,
+	RIL_UTIL_SMS_STORE_MT =	2,
+	RIL_UTIL_SMS_STORE_SR =	3,
+	RIL_UTIL_SMS_STORE_BM =	4,
+};
+
+/* 3GPP TS 27.007 Release 8 Section 5.5 */
+enum at_util_charset {
+	RIL_UTIL_CHARSET_GSM =		0x1,
+	RIL_UTIL_CHARSET_HEX =		0x2,
+	RIL_UTIL_CHARSET_IRA =		0x4,
+	RIL_UTIL_CHARSET_PCCP437 =	0x8,
+	RIL_UTIL_CHARSET_PCDN =		0x10,
+	RIL_UTIL_CHARSET_UCS2 =		0x20,
+	RIL_UTIL_CHARSET_UTF8 =		0x40,
+	RIL_UTIL_CHARSET_8859_1 =	0x80,
+	RIL_UTIL_CHARSET_8859_2 =	0x100,
+	RIL_UTIL_CHARSET_8859_3 =	0x200,
+	RIL_UTIL_CHARSET_8859_4 =	0x400,
+	RIL_UTIL_CHARSET_8859_5 =	0x800,
+	RIL_UTIL_CHARSET_8859_6 =	0x1000,
+	RIL_UTIL_CHARSET_8859_C =	0x2000,
+	RIL_UTIL_CHARSET_8859_A =	0x4000,
+	RIL_UTIL_CHARSET_8859_G =	0x8000,
+	RIL_UTIL_CHARSET_8859_H =	0x10000,
+};
+
+typedef void (*ril_util_sim_inserted_cb_t)(gboolean present, void *userdata);
+
+void decode_ril_error(struct ofono_error *error, const char *final);
+gint ril_util_call_compare_by_status(gconstpointer a, gconstpointer b);
+gint ril_util_call_compare_by_phone_number(gconstpointer a, gconstpointer b);
+gint ril_util_call_compare_by_id(gconstpointer a, gconstpointer b);
+gint ril_util_call_compare(gconstpointer a, gconstpointer b);
+
+struct ril_util_sim_state_query *ril_util_sim_state_query_new(GRil *ril,
+						guint interval, guint num_times,
+						ril_util_sim_inserted_cb_t cb,
+						void *userdata,
+						GDestroyNotify destroy);
+void ril_util_sim_state_query_free(struct ril_util_sim_state_query *req);
+
+GSList *ril_util_parse_clcc(struct ril_msg *message);
+
+gboolean ril_util_parse_reg(struct ril_msg *message, int *status,
+				int *lac, int *ci, int *tech);
+
+gint ril_util_parse_sms_response(struct ril_msg *message);
+
+gint ril_util_get_signal(struct ril_msg *message);
+
+struct cb_data {
+	void *cb;
+	void *data;
+	void *user;
+};
+
+static inline struct cb_data *cb_data_new(void *cb, void *data)
+{
+	struct cb_data *ret;
+
+	ret = g_new0(struct cb_data, 1);
+	ret->cb = cb;
+	ret->data = data;
+
+	return ret;
+}
+
+static inline int ril_util_convert_signal_strength(int strength)
+{
+	int result;
+
+	if (strength == 99)
+		result = -1;
+	else
+		result = (strength * 100) / 31;
+
+	return result;
+}
+
+#define DECLARE_FAILURE(e) 			\
+	struct ofono_error e;			\
+	e.type = OFONO_ERROR_TYPE_FAILURE;	\
+	e.error = 0				\
+
+#define CALLBACK_WITH_FAILURE(cb, args...)		\
+	do {						\
+		struct ofono_error cb_e;		\
+		cb_e.type = OFONO_ERROR_TYPE_FAILURE;	\
+		cb_e.error = 0;				\
+							\
+		cb(&cb_e, ##args);			\
+	} while (0)					\
+
+#define CALLBACK_WITH_SUCCESS(f, args...)		\
+	do {						\
+		struct ofono_error e;			\
+		e.type = OFONO_ERROR_TYPE_NO_ERROR;	\
+		e.error = 0;				\
+		f(&e, ##args);				\
+	} while (0)

=== added file 'drivers/rilmodem/sms.c'
--- drivers/rilmodem/sms.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/sms.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,357 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <glib.h>
+#include <gril.h>
+#include <parcel.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/sms.h>
+#include "smsutil.h"
+#include "util.h"
+
+#include "rilmodem.h"
+
+struct sms_data {
+        GRil *ril;
+	unsigned int vendor;
+};
+
+static void sms_debug(const gchar *str, gpointer user_data)
+{
+	const char *prefix = user_data;
+
+	ofono_info("%s%s", prefix, str);
+}
+
+static void ril_csca_set(struct ofono_sms *sms,
+			const struct ofono_phone_number *sca,
+			ofono_sms_sca_set_cb_t cb, void *user_data)
+{
+	/* TODO:
+	 *
+	 * (1) Need to determine if RIL supports setting the
+	 * SMSC number.
+	 *
+	 * (2) In the short term, this function should return
+	 * a 'not-supported' error.
+	 */
+
+        DBG("");
+
+	CALLBACK_WITH_FAILURE(cb, user_data);
+}
+
+static void ril_csca_query_cb(gboolean ok, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	ofono_sms_sca_query_cb_t cb = cbd->cb;
+	struct ofono_error error;
+	struct ofono_phone_number sca;
+
+	/* For now setup dummy number */
+        const char *number = "6176666666";
+
+	if (number[0] == '+') {
+		number = number + 1;
+		sca.type = 145;
+	} else {
+		sca.type = 129;
+	}
+
+	strncpy(sca.number, number, OFONO_MAX_PHONE_NUMBER_LENGTH);
+	sca.number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
+
+	DBG("csca_query_cb: %s, %d", sca.number, sca.type);
+
+	cb(&error, &sca, cbd->data);
+
+	return;
+}
+
+static void ril_csca_query(struct ofono_sms *sms, ofono_sms_sca_query_cb_t cb,
+					void *user_data)
+{
+	/* TODO:
+	 *
+	 * (1) Need to determine if RIL supports querying the
+	 * SMSC number.
+	 *
+	 * (2) In the short term, this function should return
+	 * a 'not-supported' error.
+	 */
+
+	CALLBACK_WITH_FAILURE(cb, NULL, user_data);
+}
+
+static void submit_sms_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_error error;
+	ofono_sms_submit_cb_t cb = cbd->cb;
+	int mr;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		decode_ril_error(&error, "FAIL");
+	}
+
+	mr = ril_util_parse_sms_response(message);
+
+	cb(&error, mr, cbd->data);
+}
+
+static void ril_cmgs(struct ofono_sms *sms, const unsigned char *pdu,
+			int pdu_len, int tpdu_len, int mms,
+			ofono_sms_submit_cb_t cb, void *user_data)
+{
+	struct sms_data *data = ofono_sms_get_data(sms);
+	struct cb_data *cbd = cb_data_new(cb, user_data);
+	struct parcel rilp;
+	char *tpdu;
+	int ret, smsc_len;
+
+        DBG("pdu_len: %d, tpdu_len: %d mms: %d", pdu_len, tpdu_len, mms);
+	g_ril_util_debug_hexdump(FALSE, pdu, pdu_len, sms_debug, "sms-pdu: ");
+
+	/* TODO: if (mms) { ... } */
+
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, 2);     /* Number of strings */
+
+	/* SMSC address:
+	 *
+	 * smsc_len == 1, then zero-length SMSC was spec'd
+	 * RILD expects a NULL string in this case instead
+	 * of a zero-length string.
+	 */
+	smsc_len = pdu_len - tpdu_len;
+	if (smsc_len > 1) {
+		/* TODO: encode SMSC & write to parcel */
+		DBG("SMSC address specified (smsc_len %d); NOT-IMPLEMENTED", smsc_len);
+	}
+
+	parcel_w_string(&rilp, NULL); /* SMSC address; NULL == default */
+
+	/* TPDU:
+	 *
+	 * 'pdu' is a raw hexadecimal string
+	 *  encode_hex() turns it into an ASCII/hex UTF8 buffer
+	 *  parcel_w_string() encodes utf8 -> utf16
+	 */
+	tpdu = encode_hex(pdu + smsc_len, tpdu_len, 0);
+	g_ril_util_debug_hexdump(FALSE, (guchar *) tpdu, (tpdu_len * 2),
+					sms_debug, "tpdu: ");
+
+	parcel_w_string(&rilp, tpdu);
+
+	/* Dump the entire parcel */
+	g_ril_util_debug_hexdump(FALSE, (guchar *) rilp.data, rilp.size,
+					sms_debug, "sms-encoded-buf: ");
+	ret = g_ril_send(data->ril,
+			RIL_REQUEST_SEND_SMS,
+			rilp.data,
+			rilp.size,
+			submit_sms_cb, cbd, g_free);
+
+	parcel_free(&rilp);
+
+	if (ret <= 0) {
+		g_free(cbd);
+		CALLBACK_WITH_FAILURE(cb, -1, data);
+	}
+}
+
+static void ril_cgsms_set(struct ofono_sms *sms, int bearer,
+			ofono_sms_bearer_set_cb_t cb, void *user_data)
+{
+        /* TODO: same as csca_set */
+        DBG("");
+
+	CALLBACK_WITH_FAILURE(cb, user_data);
+}
+
+static void ril_cgsms_query(struct ofono_sms *sms,
+				ofono_sms_bearer_query_cb_t cb, void *user_data)
+{
+        /* TODO: same as csca_query */
+        DBG("");
+
+	CALLBACK_WITH_FAILURE(cb, -1, user_data);
+}
+
+static void ril_sms_notify(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_sms *sms = user_data;
+	struct sms_data *data = ofono_sms_get_data(sms);
+	struct parcel rilp;
+	char *ril_pdu;
+	int ril_pdu_len;
+	long ril_buf_len;
+	guchar *ril_data;
+
+	DBG("req: %d; data_len: %d", message->req, message->buf_len);
+
+	if (message->req != RIL_UNSOL_RESPONSE_NEW_SMS)
+		goto error;
+
+	/* Set up Parcel struct for proper parsing */
+	rilp.data = message->buf;
+	rilp.size = message->buf_len;
+	rilp.capacity = message->buf_len;
+	rilp.offset = 0;
+
+	g_ril_util_debug_hexdump(FALSE, (guchar *) message->buf,
+		message->buf_len, sms_debug, "sms-notify: ");
+
+	ril_pdu = parcel_r_string(&rilp);
+	if (ril_pdu == NULL)
+		goto error;
+
+	ril_pdu_len = strlen(ril_pdu);
+
+	DBG("ril_pdu_len is %d", ril_pdu_len);
+	ril_data = decode_hex(ril_pdu, ril_pdu_len, &ril_buf_len, -1);
+	if (ril_data == NULL)
+		goto error;
+
+	g_ril_util_debug_hexdump(FALSE,	ril_data,
+					ril_buf_len,
+					sms_debug,
+					"sms-notify-decoded: ");
+
+	/* Last parameter is 'tpdu_len' ( substract SMSC length ) */
+	ofono_sms_deliver_notify(sms, ril_data,
+					ril_buf_len,
+					ril_buf_len - 8);
+
+	/* Re-use rilp, so initilize */
+	parcel_init(&rilp);
+	parcel_w_int32(&rilp, 2); /* Number of int32 values in array */
+	parcel_w_int32(&rilp, 1); /* Successful receipt */
+	parcel_w_int32(&rilp, 0); /* error code */
+
+	/* TODO: should ACK be sent for either of the error cases? */
+
+	/* ACK the incoming NEW_SMS; ignore response so no cb needed */
+	g_ril_send(data->ril, RIL_REQUEST_SMS_ACKNOWLEDGE,
+			rilp.data,
+			rilp.size,
+			NULL, NULL, NULL);
+
+	parcel_free(&rilp);
+	return;
+
+error:
+	ofono_error("Unable to parse NEW_SMS notification");
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_sms *sms = user_data;
+	struct sms_data *data = ofono_sms_get_data(sms);
+
+	DBG("");
+	ofono_sms_register(sms);
+
+	/* register to receive INCOMING_SMS */
+	g_ril_register(data->ril, RIL_UNSOL_RESPONSE_NEW_SMS,
+			ril_sms_notify,	sms);
+
+	DBG("registered NEW_SMS callback");
+
+        /* This makes the timeout a single-shot */
+        return FALSE;
+}
+
+static int ril_sms_probe(struct ofono_sms *sms, unsigned int vendor,
+				void *user)
+{
+	GRil *ril = user;
+	struct sms_data *data;
+
+        DBG("");
+
+	data = g_new0(struct sms_data, 1);
+	data->ril = g_ril_clone(ril);
+	data->vendor = vendor;
+
+	ofono_sms_set_data(sms, data);
+
+	/* ofono_devinfo_register() needs to be called after
+	 * the driver has been set in devinfo_create() which
+	 * calls this function.  Most other drivers use a
+	 * callback after getting some return from the modem
+	 * itself...
+	 */
+        g_timeout_add_seconds(2, ril_delayed_register, sms);
+
+	return 0;
+}
+
+static void ril_sms_remove(struct ofono_sms *sms)
+{
+	struct sms_data *data = ofono_sms_get_data(sms);
+
+        DBG("");
+
+	g_ril_unref(data->ril);
+	g_free(data);
+
+	ofono_sms_set_data(sms, NULL);
+}
+
+static struct ofono_sms_driver driver = {
+	.name		= "rilmodem",
+	.probe		= ril_sms_probe,
+	.remove		= ril_sms_remove,
+	.sca_query	= ril_csca_query,
+	.sca_set	= ril_csca_set,
+	.submit		= ril_cmgs,
+	.bearer_query	= NULL,          /* FIXME: needs investigation. */
+	.bearer_set	= NULL,
+};
+
+void ril_sms_init(void)
+{
+	DBG("");
+	if (ofono_sms_driver_register(&driver))
+		DBG("ofono_sms_driver_register failed!");
+}
+
+void ril_sms_exit(void)
+{
+	DBG("");
+	ofono_sms_driver_unregister(&driver);
+}

=== added file 'drivers/rilmodem/voicecall.c'
--- drivers/rilmodem/voicecall.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/voicecall.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,537 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+
+#include <glib.h>
+
+/* For AudioFlinger settings */
+#include <waudio.h>
+
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/voicecall.h>
+
+#include "gril.h"
+#include "grilutil.h"
+
+#include "common.h"
+
+#include "rilmodem.h"
+#include "parcel.h"
+
+/* Amount of ms we wait between CLCC calls */
+#define POLL_CLCC_INTERVAL 300
+
+/* When +VTD returns 0, an unspecified manufacturer-specific delay is used */
+#define TONE_DURATION 1000
+
+#define FLAG_NEED_CLIP 1
+
+struct voicecall_data {
+	GSList *calls;
+	unsigned int local_release;
+	unsigned int clcc_source;
+	GRil *ril;
+	unsigned int vendor;
+	unsigned int tone_duration;
+	guint vts_source;
+	unsigned int vts_delay;
+	unsigned char flags;
+};
+
+struct release_id_req {
+	struct ofono_voicecall *vc;
+	ofono_voicecall_cb_t cb;
+	void *data;
+	int id;
+};
+
+struct change_state_req {
+	struct ofono_voicecall *vc;
+	ofono_voicecall_cb_t cb;
+	void *data;
+	int affected_types;
+};
+
+static void audioflinger_set_call_mode()
+{
+	char parameter[20];
+	int i;
+
+	/* Set the call mode in AudioFlinger */
+	DBG("Setting AudioFlinger to call state");
+	AudioSystem_setMode(AUDIO_MODE_IN_CALL);
+
+	DBG("Setting sound route to earpiece");
+	sprintf(parameter, "routing=%d", AUDIO_DEVICE_OUT_EARPIECE);
+
+	/* Try the first 3 threads, as this is not fixed and there's no easy
+	 * way to retrieve the default thread/output from Android */
+	for (i = 1; i <= 3; i++) {
+		if (AudioSystem_setParameters(i, parameter) >= 0)
+			break;
+	}
+}
+
+static void audioflinger_set_normal_mode()
+{
+	char parameter[20];
+	int i;
+
+	DBG("Setting AudioFlinger to normal mode");
+	AudioSystem_setMode(AUDIO_MODE_NORMAL);
+
+	DBG("Setting sound route back to speaker");
+
+	/* Get device back to speaker mode, as by default in_call
+	 * mode sets up device out to earpiece */
+	sprintf(parameter, "routing=%d", AUDIO_DEVICE_OUT_SPEAKER);
+
+	/* Try the first 3 threads, as this is not fixed and there's no easy
+	 * way to retrieve the default thread/output from Android */
+	for (i = 1; i <= 3; i++) {
+		if (AudioSystem_setParameters(i, parameter) >= 0)
+			break;
+	}
+}
+
+static void clcc_poll_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	GSList *calls;
+	GSList *n, *o;
+	struct ofono_call *nc, *oc;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("We are polling CLCC and received an error");
+		ofono_error("All bets are off for call management");
+		return;
+	}
+
+	calls = ril_util_parse_clcc(message);
+
+	n = calls;
+	o = vd->calls;
+
+	while (n || o) {
+		nc = n ? n->data : NULL;
+		oc = o ? o->data : NULL;
+
+		if (oc && (nc == NULL || (nc->id > oc->id))) {
+			enum ofono_disconnect_reason reason;
+
+			if (vd->local_release & (1 << oc->id))
+				reason = OFONO_DISCONNECT_REASON_LOCAL_HANGUP;
+			else
+				reason = OFONO_DISCONNECT_REASON_REMOTE_HANGUP;
+
+			if (oc->type)
+				ofono_voicecall_disconnected(vc, oc->id,
+								reason, NULL);
+
+			o = o->next;
+		} else if (nc && (oc == NULL || (nc->id < oc->id))) {
+			/* new call, signal it */
+			if (nc->type)
+				ofono_voicecall_notify(vc, nc);
+
+			n = n->next;
+		} else {
+			/*
+			 * Always use the clip_validity from old call
+			 * the only place this is truly told to us is
+			 * in the CLIP notify, the rest are fudged
+			 * anyway.  Useful when RING, CLIP is used,
+			 * and we're forced to use CLCC and clip_validity
+			 * is 1
+			 */
+			if (oc->clip_validity == 1)
+				nc->clip_validity = oc->clip_validity;
+
+			nc->cnap_validity = oc->cnap_validity;
+
+			/*
+			 * CDIP doesn't arrive as part of CLCC, always
+			 * re-use from the old call
+			 */
+			memcpy(&nc->called_number, &oc->called_number,
+					sizeof(oc->called_number));
+
+			/*
+			 * If the CLIP is not provided and the CLIP never
+			 * arrives, or RING is used, then signal the call
+			 * here
+			 */
+			if (nc->status == CALL_STATUS_INCOMING &&
+					(vd->flags & FLAG_NEED_CLIP)) {
+				if (nc->type)
+					ofono_voicecall_notify(vc, nc);
+
+				vd->flags &= ~FLAG_NEED_CLIP;
+			} else if (memcmp(nc, oc, sizeof(*nc)) && nc->type)
+				ofono_voicecall_notify(vc, nc);
+
+			n = n->next;
+			o = o->next;
+		}
+	}
+
+	/* No other calls, get audioflinger into normal state */
+	if (vd->calls && !calls) {
+		audioflinger_set_normal_mode();
+	}
+
+	g_slist_foreach(vd->calls, (GFunc) g_free, NULL);
+	g_slist_free(vd->calls);
+
+	vd->calls = calls;
+	vd->local_release = 0;
+}
+
+static gboolean poll_clcc(gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+
+	g_ril_send(vd->ril, RIL_REQUEST_GET_CURRENT_CALLS, NULL,
+			0, clcc_poll_cb, vc, NULL);
+
+	vd->clcc_source = 0;
+
+	return FALSE;
+}
+
+static void generic_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct change_state_req *req = user_data;
+	struct voicecall_data *vd = ofono_voicecall_get_data(req->vc);
+	struct ofono_error error;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		decode_ril_error(&error, "FAIL");
+		goto out;
+	}
+
+	if (req->affected_types) {
+		GSList *l;
+		struct ofono_call *call;
+
+		for (l = vd->calls; l; l = l->next) {
+			call = l->data;
+
+			if (req->affected_types & (1 << call->status))
+				vd->local_release |= (1 << call->id);
+		}
+	}
+
+out:
+	g_ril_send(vd->ril, RIL_REQUEST_GET_CURRENT_CALLS, NULL,
+			0, clcc_poll_cb, req->vc, NULL);
+
+	/* We have to callback after we schedule a poll if required */
+	if (req->cb)
+		req->cb(&error, req->data);
+}
+
+static void ril_template(const guint rreq, struct ofono_voicecall *vc,
+			GRilResponseFunc func, unsigned int affected_types,
+			gpointer pdata, const gsize psize,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	struct change_state_req *req = g_try_new0(struct change_state_req, 1);
+
+	if (req == NULL)
+		goto error;
+
+	req->vc = vc;
+	req->cb = cb;
+	req->data = data;
+	req->affected_types = affected_types;
+
+	if (g_ril_send(vd->ril, rreq, pdata, psize, func, req, g_free) > 0)
+		return;
+
+error:
+	g_free(req);
+
+	if (cb)
+		CALLBACK_WITH_FAILURE(cb, data);
+}
+
+static void rild_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+	struct ofono_voicecall *vc = cbd->user;
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	ofono_voicecall_cb_t cb = cbd->cb;
+	struct ofono_error error;
+	struct ofono_call *call;
+	GSList *l;
+
+	if (message->error == RIL_E_SUCCESS) {
+		decode_ril_error(&error, "OK");
+	} else {
+		decode_ril_error(&error, "FAIL");
+		goto out;
+	}
+
+	/* On a success, make sure to put all active calls on hold */
+	for (l = vd->calls; l; l = l->next) {
+		call = l->data;
+
+		if (call->status != CALL_STATUS_ACTIVE)
+			continue;
+
+		call->status = CALL_STATUS_HELD;
+		ofono_voicecall_notify(vc, call);
+	}
+
+	/* CLCC will update the oFono call list with proper ids  */
+	if (!vd->clcc_source)
+		vd->clcc_source = g_timeout_add(POLL_CLCC_INTERVAL,
+						poll_clcc, vc);
+
+	audioflinger_set_call_mode();
+
+out:
+	cb(&error, cbd->data);
+}
+
+static void ril_dial(struct ofono_voicecall *vc,
+			const struct ofono_phone_number *ph,
+			enum ofono_clir_option clir, ofono_voicecall_cb_t cb,
+			void *data)
+{
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	struct cb_data *cbd = cb_data_new(cb, data);
+	struct parcel rilp;
+	int ret;
+
+	cbd->user = vc;
+
+	parcel_init(&rilp);
+
+	/* Number to dial */
+        parcel_w_string(&rilp, phone_number_to_string(ph));
+	/* CLIR mode */
+	parcel_w_int32(&rilp, clir);
+	/* USS, need it twice for absent */
+	/* TODO: Deal with USS properly */
+	parcel_w_int32(&rilp, 0);
+	parcel_w_int32(&rilp, 0);
+
+	/* Send request to RIL */
+	ret = g_ril_send(vd->ril, RIL_REQUEST_DIAL, rilp.data,
+				rilp.size, rild_cb, cbd, g_free);
+	parcel_free(&rilp);
+
+	/* In case of error free cbd and return the cb with failure */
+	if (ret <= 0) {
+		g_free(cbd);
+		CALLBACK_WITH_FAILURE(cb, data);
+	}
+}
+
+static void ril_hangup_all(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	struct parcel rilp;
+	struct ofono_error error;
+	struct ofono_call *call;
+	GSList *l;
+
+	for (l = vd->calls; l; l = l->next) {
+		call = l->data;
+		/* TODO: Hangup just the active ones once we have call
+		 * state tracking (otherwise it can't handle ringing) */
+		DBG("Hanging up call with id %d", call->id);
+		parcel_init(&rilp);
+		parcel_w_int32(&rilp, 1); /* Always 1 - AT+CHLD=1x */
+		parcel_w_int32(&rilp, call->id);
+
+		/* Send request to RIL */
+		ril_template(RIL_REQUEST_HANGUP, vc, generic_cb, 0x3f,
+				rilp.data, rilp.size, NULL, NULL);
+		parcel_free(&rilp);
+	}
+
+	/* TODO: Deal in case of an error at hungup */
+	decode_ril_error(&error, "OK");
+	cb(&error, data);
+}
+
+static void ril_call_state_notify(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+
+	if (message->req != RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED)
+		goto error;
+
+	/* Just need to request the call list again */
+	poll_clcc(vc);
+
+	return;
+
+error:
+	ofono_error("Unable to notify about call state changes");
+}
+
+static void ril_answer(struct ofono_voicecall *vc,
+			ofono_voicecall_cb_t cb, void *data)
+{
+	DBG("Answering current call");
+
+	/* Send request to RIL */
+	ril_template(RIL_REQUEST_ANSWER, vc, generic_cb, 0,
+				NULL, 0, cb, data);
+
+	audioflinger_set_call_mode();
+}
+
+static void ril_send_dtmf(struct ofono_voicecall *vc, const char *dtmf,
+		ofono_voicecall_cb_t cb, void *data)
+{
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	int len = strlen(dtmf);
+	struct parcel rilp;
+	struct ofono_error error;
+	char *ril_dtmf = g_try_malloc(sizeof(char) * 2);
+	int i;
+
+	DBG("");
+
+	/* Ril wants just one character, but we need to send as string */
+	ril_dtmf[1] = '\0';
+
+	for (i = 0; i < len; i++) {
+		parcel_init(&rilp);
+		ril_dtmf[0] = dtmf[i];
+		parcel_w_string(&rilp, ril_dtmf);
+		DBG("DTMF: Sending %s", ril_dtmf);
+		g_ril_send(vd->ril, RIL_REQUEST_DTMF, rilp.data,
+				rilp.size, NULL, NULL, NULL);
+		parcel_free(&rilp);
+	}
+
+	free(ril_dtmf);
+
+	/* We don't really care about errors here */
+	decode_ril_error(&error, "OK");
+	cb(&error, data);
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+	ofono_voicecall_register(vc);
+
+	/* Initialize call list */
+	poll_clcc(vc);
+
+	/* Unsol when call state changes */
+	g_ril_register(vd->ril, RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED,
+			ril_call_state_notify, vc);
+
+	/* This makes the timeout a single-shot */
+	return FALSE;
+}
+
+static int ril_voicecall_probe(struct ofono_voicecall *vc, unsigned int vendor,
+				void *data)
+{
+	GRil *ril = data;
+	struct voicecall_data *vd;
+
+	vd = g_try_new0(struct voicecall_data, 1);
+	if (vd == NULL)
+		return -ENOMEM;
+
+	vd->ril = g_ril_clone(ril);
+	vd->vendor = vendor;
+	vd->tone_duration = TONE_DURATION;
+
+	ofono_voicecall_set_data(vc, vd);
+
+	/* ofono_devinfo_register() needs to be called after
+	 * the driver has been set in devinfo_create() which
+	 * calls this function.  Most other drivers use a
+	 * callback after getting some return from the modem
+	 * itself...
+	 */
+        g_timeout_add_seconds(2, ril_delayed_register, vc);
+
+	return 0;
+}
+
+static void ril_voicecall_remove(struct ofono_voicecall *vc)
+{
+	struct voicecall_data *vd = ofono_voicecall_get_data(vc);
+
+	if (vd->clcc_source)
+		g_source_remove(vd->clcc_source);
+
+	if (vd->vts_source)
+		g_source_remove(vd->vts_source);
+
+	g_slist_foreach(vd->calls, (GFunc) g_free, NULL);
+	g_slist_free(vd->calls);
+
+	ofono_voicecall_set_data(vc, NULL);
+
+	g_ril_unref(vd->ril);
+	g_free(vd);
+}
+
+static struct ofono_voicecall_driver driver = {
+	.name			= "rilmodem",
+	.probe			= ril_voicecall_probe,
+	.remove			= ril_voicecall_remove,
+	.dial			= ril_dial,
+	.answer			= ril_answer,
+	.hangup_all		= ril_hangup_all,
+	.send_tones		= ril_send_dtmf
+};
+
+void ril_voicecall_init(void)
+{
+	ofono_voicecall_driver_register(&driver);
+}
+
+void ril_voicecall_exit(void)
+{
+	ofono_voicecall_driver_unregister(&driver);
+}

=== added directory 'gril'
=== added file 'gril/gfunc.h'
--- gril/gfunc.h	1970-01-01 00:00:00 +0000
+++ gril/gfunc.h	2013-04-09 20:01:20 +0000
@@ -0,0 +1,42 @@
+/*
+ *
+ *  RIL library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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 __GFUNC_H
+#define __GFUNC_H
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void (*GRilDisconnectFunc)(gpointer user_data);
+typedef void (*GRilReceiveFunc)(const unsigned char *data, gsize size,
+							gpointer user_data);
+typedef void (*GRilDebugFunc)(const char *str, gpointer user_data);
+typedef void (*GRilSuspendFunc)(gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GFUNC_H */

=== added file 'gril/gril.c'
--- gril/gril.c	1970-01-01 00:00:00 +0000
+++ gril/gril.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,1160 @@
+/*
+ *
+ *  RIL library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/in.h>
+
+#include <glib.h>
+
+#include "log.h"
+#include "ringbuffer.h"
+#include "gril.h"
+
+#define COMMAND_FLAG_EXPECT_PDU			0x1
+#define COMMAND_FLAG_EXPECT_SHORT_PROMPT	0x2
+
+#define RILD_CMD_SOCKET "/dev/socket/rild"
+#define RILD_DBG_SOCKET "/dev/socket/rild-debug"
+
+struct ril_request {
+	gchar *req;
+	guint req_len;
+	guint id;
+	guint gid;
+	GRilResponseFunc callback;
+	gpointer user_data;
+	GDestroyNotify notify;
+};
+
+struct ril_notify_node {
+	guint id;
+	guint gid;
+	GRilNotifyFunc callback;
+	gpointer user_data;
+	gboolean destroyed;
+};
+
+typedef gboolean (*node_remove_func)(struct ril_notify_node *node,
+					gpointer user_data);
+
+struct ril_notify {
+	GSList *nodes;
+};
+
+struct ril_s {
+	gint ref_count;				/* Ref count */
+	guint next_cmd_id;			/* Next command id */
+	guint next_notify_id;			/* Next notify id */
+	guint next_gid;				/* Next group id */
+	GRilIO *io;				/* GRil IO */
+	GQueue *command_queue;			/* Command queue */
+	guint req_bytes_written;		/* bytes written from req */
+	GHashTable *notify_list;		/* List of notification reg */
+	GRilDisconnectFunc user_disconnect;	/* user disconnect func */
+	gpointer user_disconnect_data;		/* user disconnect data */
+	guint read_so_far;			/* Number of bytes processed */
+	gboolean suspended;			/* Are we suspended? */
+	GRilDebugFunc debugf;			/* debugging output function */
+	gpointer debug_data;			/* Data to pass to debug func */
+	GSList *response_lines;			/* char * lines of the response */
+	gint timeout_source;
+	gboolean destroyed;			/* Re-entrancy guard */
+	gboolean in_read_handler;		/* Re-entrancy guard */
+	gboolean in_notify;
+};
+
+struct _GRil {
+	gint ref_count;
+	struct ril_s *parent;
+	guint group;
+};
+
+/*
+ * This struct represents the header of a RIL reply.
+ * It does not include the Big Endian UINT32 length prefix.
+ */
+struct ril_reply {
+	guint32 reply;                          /* LE: should be 0 */
+	guint32 serial_no;                      /* LE: used to match requests */
+	guint32 error_code;                     /* LE: */
+};
+
+static void ril_wakeup_writer(struct ril_s *ril);
+
+static void ril_notify_node_destroy(gpointer data, gpointer user_data)
+{
+	struct ril_notify_node *node = data;
+	g_free(node);
+}
+
+static void ril_notify_destroy(gpointer user_data)
+{
+	struct ril_notify *notify = user_data;
+
+	g_slist_foreach(notify->nodes, ril_notify_node_destroy, NULL);
+	g_slist_free(notify->nodes);
+	g_free(notify);
+}
+
+static gint ril_notify_node_compare_by_id(gconstpointer a, gconstpointer b)
+{
+	const struct ril_notify_node *node = a;
+	guint id = GPOINTER_TO_UINT(b);
+
+	if (node->id < id)
+		return -1;
+
+	if (node->id > id)
+		return 1;
+
+	return 0;
+}
+
+static gboolean ril_unregister_all(struct ril_s *ril,
+					gboolean mark_only,
+					node_remove_func func,
+					gpointer userdata)
+{
+	GHashTableIter iter;
+	struct ril_notify *notify;
+	struct ril_notify_node *node;
+	gpointer key, value;
+	GSList *p;
+	GSList *c;
+	GSList *t;
+
+	if (ril->notify_list == NULL)
+		return FALSE;
+
+	g_hash_table_iter_init(&iter, ril->notify_list);
+
+	while (g_hash_table_iter_next(&iter, &key, &value)) {
+		notify = value;
+
+		p = NULL;
+		c = notify->nodes;
+
+		while (c) {
+			node = c->data;
+
+			if (func(node, userdata) != TRUE) {
+				p = c;
+				c = c->next;
+				continue;
+			}
+
+			if (mark_only) {
+				node->destroyed = TRUE;
+				p = c;
+				c = c->next;
+				continue;
+			}
+
+			if (p)
+				p->next = c->next;
+			else
+				notify->nodes = c->next;
+
+			ril_notify_node_destroy(node, NULL);
+
+			t = c;
+			c = c->next;
+			g_slist_free_1(t);
+		}
+
+		if (notify->nodes == NULL)
+			g_hash_table_iter_remove(&iter);
+	}
+
+	return TRUE;
+}
+
+/* TODO: move to grilutil.h */
+static const char *err_name(int error)
+{
+	switch(error) {
+	case RIL_E_SUCCESS: return "SUCCESS";
+	case RIL_E_RADIO_NOT_AVAILABLE: return "RADIO_NOT_AVAILABLE";
+	case RIL_E_GENERIC_FAILURE: return "GENERIC_FAILURE";
+	case RIL_E_PASSWORD_INCORRECT: return "PASSWORD_INCORRECT";
+	case RIL_E_SIM_PIN2: return "SIM_PIN2";
+	case RIL_E_SIM_PUK2: return "SIM_PUK2";
+	case RIL_E_REQUEST_NOT_SUPPORTED: return "REQUEST_NOT_SUPPORTED";
+	case RIL_E_CANCELLED: return "CANCELLED";
+	case RIL_E_OP_NOT_ALLOWED_DURING_VOICE_CALL: return "OP_NOT_ALLOWED_DURING_VOICE_CALL";
+	case RIL_E_OP_NOT_ALLOWED_BEFORE_REG_TO_NW: return "OP_NOT_ALLOWED_BEFORE_REG_TO_NW";
+	case RIL_E_SMS_SEND_FAIL_RETRY: return "SMS_SEND_FAIL_RETRY";
+	case RIL_E_SIM_ABSENT: return "SIM_ABSENT";
+	case RIL_E_SUBSCRIPTION_NOT_AVAILABLE: return "SUBSCRIPTION_NOT_AVAILABLE";
+	case RIL_E_MODE_NOT_SUPPORTED: return "MODE_NOT_SUPPORTED";
+	case RIL_E_FDN_CHECK_FAILURE: return "FDN_CHECK_FAILURE";
+	case RIL_E_ILLEGAL_SIM_OR_ME: return "ILLEGAL_SIM_OR_ME";
+	default: return "<unknown errno>";
+	}
+}
+
+/* TODO: move to grilutil.h */
+static const char *unsol_request_name(int request)
+{
+	switch(request) {
+        case RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED: return "UNSOL_RESPONSE_RADIO_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED: return "UNSOL_RESPONSE_CALL_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED: return "UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED";
+        case RIL_UNSOL_RESPONSE_NEW_SMS: return "UNSOL_RESPONSE_NEW_SMS";
+        case RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT: return "UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT";
+        case RIL_UNSOL_RESPONSE_NEW_SMS_ON_SIM: return "UNSOL_RESPONSE_NEW_SMS_ON_SIM";
+        case RIL_UNSOL_ON_USSD: return "UNSOL_ON_USSD";
+        case RIL_UNSOL_ON_USSD_REQUEST: return "UNSOL_ON_USSD_REQUEST(obsolete)";
+        case RIL_UNSOL_NITZ_TIME_RECEIVED: return "UNSOL_NITZ_TIME_RECEIVED";
+        case RIL_UNSOL_SIGNAL_STRENGTH: return "UNSOL_SIGNAL_STRENGTH";
+        case RIL_UNSOL_STK_SESSION_END: return "UNSOL_STK_SESSION_END";
+        case RIL_UNSOL_STK_PROACTIVE_COMMAND: return "UNSOL_STK_PROACTIVE_COMMAND";
+        case RIL_UNSOL_STK_EVENT_NOTIFY: return "UNSOL_STK_EVENT_NOTIFY";
+        case RIL_UNSOL_STK_CALL_SETUP: return "UNSOL_STK_CALL_SETUP";
+        case RIL_UNSOL_SIM_SMS_STORAGE_FULL: return "UNSOL_SIM_SMS_STORAGE_FUL";
+        case RIL_UNSOL_SIM_REFRESH: return "UNSOL_SIM_REFRESH";
+        case RIL_UNSOL_DATA_CALL_LIST_CHANGED: return "UNSOL_DATA_CALL_LIST_CHANGED";
+        case RIL_UNSOL_CALL_RING: return "UNSOL_CALL_RING";
+        case RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED: return "UNSOL_RESPONSE_SIM_STATUS_CHANGED";
+        case RIL_UNSOL_RESPONSE_CDMA_NEW_SMS: return "UNSOL_NEW_CDMA_SMS";
+        case RIL_UNSOL_RESPONSE_NEW_BROADCAST_SMS: return "UNSOL_NEW_BROADCAST_SMS";
+        case RIL_UNSOL_CDMA_RUIM_SMS_STORAGE_FULL: return "UNSOL_CDMA_RUIM_SMS_STORAGE_FULL";
+        case RIL_UNSOL_RESTRICTED_STATE_CHANGED: return "UNSOL_RESTRICTED_STATE_CHANGED";
+        case RIL_UNSOL_ENTER_EMERGENCY_CALLBACK_MODE: return "UNSOL_ENTER_EMERGENCY_CALLBACK_MODE";
+        case RIL_UNSOL_CDMA_CALL_WAITING: return "UNSOL_CDMA_CALL_WAITING";
+        case RIL_UNSOL_CDMA_OTA_PROVISION_STATUS: return "UNSOL_CDMA_OTA_PROVISION_STATUS";
+        case RIL_UNSOL_CDMA_INFO_REC: return "UNSOL_CDMA_INFO_REC";
+        case RIL_UNSOL_OEM_HOOK_RAW: return "UNSOL_OEM_HOOK_RAW";
+        case RIL_UNSOL_RINGBACK_TONE: return "UNSOL_RINGBACK_TONE";
+        case RIL_UNSOL_RESEND_INCALL_MUTE: return "UNSOL_RESEND_INCALL_MUTE";
+        case RIL_UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED: return "UNSOL_CDMA_SUBSCRIPTION_SOURCE_CHANGED";
+        case RIL_UNSOL_CDMA_PRL_CHANGED: return "UNSOL_CDMA_PRL_CHANGED";
+        case RIL_UNSOL_EXIT_EMERGENCY_CALLBACK_MODE: return "UNSOL_EXIT_EMERGENCY_CALLBACK_MODE";
+        case RIL_UNSOL_RIL_CONNECTED: return "UNSOL_RIL_CONNECTED";
+        default:
+		DBG("Got unknown request number %d", request);
+		return "<unknown request>";
+	}
+}
+
+/*
+ * This function creates a RIL request.  For a good reference on
+ * the layout of RIL requests, responses, and unsolicited requests
+ * see:
+ *
+ * https://wiki.mozilla.org/B2G/RIL
+ *
+ */
+static struct ril_request *ril_request_create(struct ril_s *ril,
+						guint gid,
+						const guint req,
+						const guint id,
+						const char *data,
+						const gsize data_len,
+						GRilResponseFunc func,
+						gpointer user_data,
+						GDestroyNotify notify,
+						gboolean wakeup)
+{
+	struct ril_request *r;
+	gsize len;
+	gchar *cur_bufp;
+	guint32 *net_length, *request, *serial_no;
+
+	r = g_try_new0(struct ril_request, 1);
+	if (r == NULL)
+		return 0;
+
+        DBG("req: %s, id: %d, data_len: %d",
+		ril_request_id_to_string(req), id, data_len);
+
+        /* RIL request: 8 byte header + data */
+        len = 8 + data_len;
+
+        /* Add 4 bytes to buffer length to include length prefix */
+        r->req_len = len + 4;
+
+	r->req = g_try_new(char, r->req_len);
+	if (r->req == NULL) {
+		ofono_error("ril_request: can't allocate new request.");
+		g_free(r);
+		return 0;
+	}
+
+        /* convert length to network byte order (Big Endian) */
+        net_length = (guint32 *) r->req;
+        *net_length = htonl(len);
+
+	/* advance past initial length */
+        cur_bufp = r->req + 4;
+
+	/* write request code */
+	request = (guint32 *) cur_bufp;
+	*request = req;
+	cur_bufp += 4;
+
+	/* write serial number */
+	serial_no = (guint32 *) cur_bufp;
+	*serial_no = id;
+	cur_bufp += 4;
+
+	/* copy request data */
+	memcpy(cur_bufp, (const void *) data, data_len);
+
+	r->gid = gid;
+	r->id = id;
+	r->callback = func;
+	r->user_data = user_data;
+	r->notify = notify;
+
+	return r;
+}
+
+static void ril_request_destroy(struct ril_request *req)
+{
+	if (req->notify)
+		req->notify(req->user_data);
+
+	g_free(req->req);
+	g_free(req);
+}
+
+static void ril_cleanup(struct ril_s *p)
+{
+	/* Cleanup pending commands */
+
+	g_queue_free(p->command_queue);
+        p->command_queue = NULL;
+
+	/* Cleanup any response lines we have pending */
+	g_slist_foreach(p->response_lines, (GFunc)g_free, NULL);
+	g_slist_free(p->response_lines);
+	p->response_lines = NULL;
+
+	/* Cleanup registered notifications */
+
+	if (p->notify_list)
+		g_hash_table_destroy(p->notify_list);
+
+	p->notify_list = NULL;
+
+	if (p->timeout_source) {
+		g_source_remove(p->timeout_source);
+		p->timeout_source = 0;
+	}
+}
+
+static void io_disconnect(gpointer user_data)
+{
+	struct ril_s *ril = user_data;
+
+	ril_cleanup(ril);
+	g_ril_io_unref(ril->io);
+	ril->io = NULL;
+
+	if (ril->user_disconnect)
+		ril->user_disconnect(ril->user_disconnect_data);
+}
+
+static void handle_response(struct ril_s *p, struct ril_msg *message)
+{
+	gsize count = g_queue_get_length(p->command_queue);
+	struct ril_request *req;
+	int i;
+
+	g_assert(count > 0);
+
+	for (i = 0; i < count; i++) {
+		req = g_queue_peek_nth(p->command_queue, i);
+		DBG("comparing req->id: %d to message->serial_no: %d",
+			req->id, message->serial_no);
+
+		if (req->id == message->serial_no) {
+			req = g_queue_pop_nth(p->command_queue, i);
+
+			if (req->callback)
+				req->callback(message, req->user_data);
+
+			ril_request_destroy(req);
+
+			if (g_queue_peek_head(p->command_queue))
+				ril_wakeup_writer(p);
+			/*
+			 * TODO: there's a flaw in the current logic.
+			 * If a matching response isn't received,
+			 * req_bytes_written doesn't get reset.
+			 * gatchat has the concept of modem wakeup,
+			 * which is a failsafe way of making sure
+			 * cmd_bytes_written gets reset, however if
+			 * the modem isn't configured for wakeup,
+			 * it may have the same problem.  Perhaps
+			 * we should consider adding a timer?
+			 */
+			p->req_bytes_written = 0;
+
+			/* Found our matching one */
+			break;
+		}
+	}
+}
+
+static void handle_unsol_req(struct ril_s *p, struct ril_msg *message)
+{
+	GHashTableIter iter;
+	struct ril_notify *notify;
+	int req_key;
+	gpointer key, value;
+	GList *list_item;
+	struct ril_notify_node *node;
+
+	if (p->notify_list == NULL)
+		return;
+
+	p->in_notify = TRUE;
+
+	g_hash_table_iter_init(&iter, p->notify_list);
+
+	while (g_hash_table_iter_next(&iter, &key, &value)) {
+		req_key = *((int *)key);
+		notify = value;
+
+		DBG("checking req_key: %d to req: %d", req_key, message->req);
+
+		if (req_key != message->req)
+			continue;
+
+		list_item = notify->nodes;
+
+		while (list_item != NULL) {
+			node = list_item->data;
+
+			DBG("about to callback: notify: %x, node: %x, notify->nodes: %x, callback: %x",
+				notify, node, notify->nodes, node->callback);
+
+			node->callback(message, node->user_data);
+
+			list_item = g_slist_next(list_item);
+		}
+	}
+
+	p->in_notify = FALSE;
+}
+
+static void dispatch(struct ril_s *p, struct ril_msg *message)
+{
+	guint32 *unsolicited_field, *id_num_field;
+	gchar *bufp = message->buf;
+	gchar *datap;
+	gsize data_len;
+
+	/* This could be done with a struct/union... */
+	unsolicited_field = (guint32 *) bufp;
+	if (*unsolicited_field)
+		message->unsolicited = TRUE;
+	else
+		message->unsolicited = FALSE;
+
+	bufp += 4;
+
+	id_num_field = (guint32 *) bufp;
+	if (message->unsolicited) {
+		message->req = (int) *id_num_field;
+
+		/*
+		 * A RIL Unsolicited Event is two UINT32 fields ( unsolicited, and req/ev ),
+		 * so subtract the length of the header from the overall length to calculate
+		 * the length of the Event Data.
+		 */
+		data_len = message->buf_len - 8;
+	} else {
+		message->serial_no = (int) *id_num_field;
+
+		bufp += 4;
+		message->error = *((guint32 *) bufp);
+
+		/*
+		 * A RIL Solicited Response is three UINT32 fields ( unsolicied, serial_no
+		 * and error ), so subtract the length of the header from the overall length
+		 * to calculate the length of the Event Data.
+		 */
+		data_len = message->buf_len - 12;
+	}
+
+        /* advance to start of data.. */
+	bufp += 4;
+
+	/* Now, allocate new buffer for data only, copy from
+	 * original, and free the original...
+	 */
+	if (data_len) {
+		datap = g_try_malloc(data_len);
+		if (datap == NULL)
+			goto error;
+
+		/* Copy bytes into new buffer */
+		memmove(datap, (const void *) bufp, data_len);
+
+		/* Free old buffer */
+		g_free(message->buf);
+
+		/* ...and replace with new buffer */
+		message->buf = datap;
+		message->buf_len = data_len;
+	}
+
+	if (message->unsolicited == TRUE) {
+		DBG("RIL Event: %s\n", unsol_request_name(message->req));
+
+		handle_unsol_req(p, message);
+	} else {
+		DBG("RIL Reply: serial-no: %d errno: %s\n",
+			message->serial_no,
+			err_name(message->error));
+
+		handle_response(p, message);
+	}
+error:
+	g_free(message->buf);
+	g_free(message);
+}
+
+static struct ril_msg *read_fixed_record(struct ril_s *p,
+						const guchar *bytes, gsize *len)
+{
+	struct ril_msg *message;
+	int message_len, plen;
+
+	/* First four bytes are length in TCP byte order (Big Endian) */
+	plen = ntohl(*((uint32_t *) bytes));
+	bytes += 4;
+
+	/* TODO: Verify that 4k is the max message size from rild.
+	 *
+	 * These conditions shouldn't happen.  If it does
+	 * there are three options:
+	 *
+	 * 1) ASSERT; ofono will restart via DBus
+	 * 2) Consume the bytes & continue
+	 * 3) force a disconnect
+	 */
+	g_assert(plen >= 8 && plen <= 4092);
+
+	/* If we don't have the whole fixed record in the ringbuffer
+	 * then return NULL & leave ringbuffer as is.
+	*/
+
+	message_len = *len - 4;
+	if (message_len < plen) {
+		return NULL;
+	}
+
+	/* FIXME: add check for message_len = 0? */
+
+        message = g_try_malloc(sizeof(struct ril_msg));
+        g_assert(message != NULL);
+
+        /* allocate ril_msg->buffer */
+        message->buf_len = plen;
+        message->buf = g_try_malloc(plen);
+        g_assert(message->buf != NULL);
+
+        /* Copy bytes into message buffer */
+        memmove(message->buf, (const void *) bytes, plen);
+
+	/* Indicate to caller size of record we extracted */
+	*len = plen + 4;
+	return message;
+}
+
+static void new_bytes(struct ring_buffer *rbuf, gpointer user_data)
+{
+	struct ril_msg *message;
+	struct ril_s *p = user_data;
+	unsigned int len = ring_buffer_len(rbuf);
+	unsigned int wrap = ring_buffer_len_no_wrap(rbuf);
+	guchar *buf = ring_buffer_read_ptr(rbuf, p->read_so_far);
+
+	p->in_read_handler = TRUE;
+
+	DBG("len: %d, wrap: %d", len, wrap);
+
+	while (p->suspended == FALSE && (p->read_so_far < len)) {
+		gsize rbytes = MIN(len - p->read_so_far, wrap - p->read_so_far);
+
+		if (rbytes < 4) {
+			DBG("Not enough bytes for header length: len: %d", len);
+			return;
+		}
+
+		/* this function attempts to read the next full length
+		 * fixed message from the stream.  if not all bytes are
+		 * available, it returns NULL.  otherwise it allocates
+		 * and returns a ril_message with the copied bytes, and
+		 * drains those bytes from the ring_buffer
+		 */
+		message = read_fixed_record(p, buf, &rbytes);
+
+		/* wait for the rest of the record... */
+		if (message == NULL) {
+			DBG("Not enough bytes for fixed record");
+			break;
+		}
+
+		buf += rbytes;
+		p->read_so_far += rbytes;
+
+		/* TODO: need to better understand how wrap works! */
+		if (p->read_so_far == wrap) {
+			buf = ring_buffer_read_ptr(rbuf, p->read_so_far);
+			wrap = len;
+		}
+
+		dispatch(p, message);
+
+		ring_buffer_drain(rbuf, p->read_so_far);
+
+		len -= p->read_so_far;
+		wrap -= p->read_so_far;
+		p->read_so_far = 0;
+	}
+
+	p->in_read_handler = FALSE;
+
+	if (p->destroyed)
+		g_free(p);
+}
+
+static gboolean can_write_data(gpointer data)
+{
+	struct ril_s *ril = data;
+	struct ril_request *req;
+	gsize bytes_written;
+	gsize towrite;
+	gsize len;
+
+	/* Grab the first command off the queue and write as
+	 * much of it as we can
+	 */
+	req = g_queue_peek_head(ril->command_queue);
+
+	/* For some reason command queue is empty, cancel write watcher */
+	if (req == NULL)
+		return FALSE;
+
+	len = req->req_len;
+	DBG("len: %d, req_bytes_written: %d", len, ril->req_bytes_written);
+
+	/* For some reason write watcher fired, but we've already
+	 * written the entire command out to the io channel,
+	 * cancel write watcher
+	 */
+	if (ril->req_bytes_written >= len)
+		return FALSE;
+
+        /*
+	 * AT modems need to be woken up via a command set by the
+	 * upper layers.  RIL has no such concept, hence wakeup needed
+	 * NOTE - I'm keeping the if statement here commented out, just
+	 * in case this concept needs to be added back in...
+	 *
+	 * if (ril->req_bytes_written == 0 && wakeup_first == TRUE) {
+	 *		cmd = at_command_create(0, chat->wakeup, none_prefix, 0,
+	 *					NULL, wakeup_cb, chat, NULL, TRUE);
+	 *		g_queue_push_head(chat->command_queue, cmd);
+	 *	len = strlen(chat->wakeup);
+	 *	chat->timeout_source = g_timeout_add(chat->wakeup_timeout,
+	 *					wakeup_no_response, chat);
+	 *	}
+	 */
+
+	towrite = len - ril->req_bytes_written;
+
+#ifdef WRITE_SCHEDULER_DEBUG
+	if (towrite > 5)
+		towrite = 5;
+#endif
+
+	bytes_written = g_ril_io_write(ril->io,
+					req->req + ril->req_bytes_written,
+					towrite);
+
+	DBG("bytes_written: %d", bytes_written);
+
+	if (bytes_written == 0)
+		return FALSE;
+
+	ril->req_bytes_written += bytes_written;
+	if (bytes_written < towrite)
+		return TRUE;
+
+	return FALSE;
+}
+
+static void ril_wakeup_writer(struct ril_s *ril)
+{
+	g_ril_io_set_write_handler(ril->io, can_write_data, ril);
+}
+
+static void ril_suspend(struct ril_s *ril)
+{
+	ril->suspended = TRUE;
+
+	g_ril_io_set_write_handler(ril->io, NULL, NULL);
+	g_ril_io_set_read_handler(ril->io, NULL, NULL);
+        g_ril_io_set_debug(ril->io, NULL, NULL);
+}
+
+/*
+ * TODO: need to determine when ril_resume/suspend are called.
+ *
+ * Most likely, this is in response to DBUS messages sent to
+ * oFono to tell it the system is suspending/resuming.
+ */
+static void ril_resume(struct ril_s *ril)
+{
+	ril->suspended = FALSE;
+
+	if (g_ril_io_get_channel(ril->io) == NULL) {
+        	io_disconnect(ril);
+        	return;
+        }
+
+	g_ril_io_set_disconnect_function(ril->io, io_disconnect, ril);
+
+	g_ril_io_set_debug(ril->io, ril->debugf, ril->debug_data);
+
+	g_ril_io_set_read_handler(ril->io, new_bytes, ril);
+
+	if (g_queue_get_length(ril->command_queue) > 0)
+	        ril_wakeup_writer(ril);
+}
+
+static gboolean ril_set_debug(struct ril_s *ril,
+				GRilDebugFunc func, gpointer user_data)
+{
+
+	ril->debugf = func;
+	ril->debug_data = user_data;
+
+	if (ril->io)
+		g_ril_io_set_debug(ril->io, func, user_data);
+
+	return TRUE;
+}
+
+static void ril_unref(struct ril_s *ril)
+{
+	gboolean is_zero;
+
+	is_zero = g_atomic_int_dec_and_test(&ril->ref_count);
+
+	if (is_zero == FALSE)
+		return;
+
+        if (ril->io) {
+        	ril_suspend(ril);
+		g_ril_io_unref(ril->io);
+        	ril->io = NULL;
+        	ril_cleanup(ril);
+        }
+
+	if (ril->in_read_handler)
+		ril->destroyed = TRUE;
+	else
+		g_free(ril);
+}
+
+static gboolean node_compare_by_group(struct ril_notify_node *node,
+					gpointer userdata)
+{
+	guint group = GPOINTER_TO_UINT(userdata);
+
+	if (node->gid == group)
+		return TRUE;
+
+	return FALSE;
+}
+
+static struct ril_s *create_ril()
+
+{
+	struct ril_s *ril;
+	struct sockaddr_un addr;
+	int sk;
+	GIOChannel *io;
+
+	ril = g_try_new0(struct ril_s, 1);
+	if (ril == NULL)
+		return ril;
+
+	ril->ref_count = 1;
+	ril->next_cmd_id = 1;
+	ril->next_notify_id = 1;
+	ril->next_gid = 0;
+	ril->debugf = NULL;
+	ril->req_bytes_written = 0;
+
+	sk = socket(AF_UNIX, SOCK_STREAM, 0);
+	if (sk < 0) {
+		ofono_error("create_ril: can't create unix socket: %s (%d)\n",
+				strerror(errno), errno);
+		goto error;
+	}
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, RILD_CMD_SOCKET, sizeof(addr.sun_path) - 1);
+
+	if (connect(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+		ofono_error("create_ril: can't connect to RILD: %s (%d)\n",
+				strerror(errno), errno);
+		goto error;
+	}
+
+        io = g_io_channel_unix_new(sk);
+        if (io == NULL) {
+		ofono_error("create_ril: can't connect to RILD: %s (%d)\n",
+				strerror(errno), errno);
+		return NULL;
+        }
+
+	g_io_channel_set_buffered(io, FALSE);
+	g_io_channel_set_encoding(io, NULL, NULL);
+	g_io_channel_set_close_on_unref(io, TRUE);
+	g_io_channel_set_flags(io, G_IO_FLAG_NONBLOCK, NULL);
+
+        ril->io = g_ril_io_new(io);
+        if (ril->io == NULL) {
+		ofono_error("create_ril: can't create ril->io");
+        	goto error;
+	}
+
+	g_ril_io_set_disconnect_function(ril->io, io_disconnect, ril);
+
+	ril->command_queue = g_queue_new();
+	if (ril->command_queue == NULL) {
+		ofono_error("create_ril: Couldn't create command_queue.");
+		goto error;
+	}
+
+	ril->notify_list = g_hash_table_new_full(g_int_hash, g_int_equal,
+							g_free, ril_notify_destroy);
+
+        g_ril_io_set_read_handler(ril->io, new_bytes, ril);
+
+	return ril;
+
+error:
+        g_ril_io_unref(ril->io);
+
+	if (ril->command_queue)
+		g_queue_free(ril->command_queue);
+
+	if (ril->notify_list)
+		g_hash_table_destroy(ril->notify_list);
+
+	g_free(ril);
+	return NULL;
+}
+
+static struct ril_notify *ril_notify_create(struct ril_s *ril,
+						const int req)
+{
+	struct ril_notify *notify;
+	int *key;
+
+	notify = g_try_new0(struct ril_notify, 1);
+	if (notify == NULL)
+		return 0;
+
+	key = g_try_new0(int, 1);
+	if (key == NULL)
+		return 0;
+
+	*key = req;
+
+	g_hash_table_insert(ril->notify_list, key, notify);
+
+	return notify;
+}
+
+static guint ril_register(struct ril_s *ril, guint group,
+				const int req, GRilNotifyFunc func,
+				gpointer user_data)
+{
+	struct ril_notify *notify;
+	struct ril_notify_node *node;
+
+	if (ril->notify_list == NULL)
+		return 0;
+
+	if (func == NULL)
+		return 0;
+
+	notify = g_hash_table_lookup(ril->notify_list, &req);
+
+	if (notify == NULL)
+		notify = ril_notify_create(ril, req);
+
+	if (notify == NULL)
+		return 0;
+
+	node = g_try_new0(struct ril_notify_node, 1);
+	if (node == NULL)
+		return 0;
+
+	node->id = ril->next_notify_id++;
+	node->gid = group;
+	node->callback = func;
+	node->user_data = user_data;
+
+	notify->nodes = g_slist_prepend(notify->nodes, node);
+	DBG("after pre-pend; notify: %x, node %x, notify->nodes: %x, callback: %x",
+		notify, node, notify->nodes, node->callback);
+
+	return node->id;
+}
+
+static gboolean ril_unregister(struct ril_s *ril, gboolean mark_only,
+					guint group, guint id)
+{
+	GHashTableIter iter;
+	struct ril_notify *notify;
+	struct ril_notify_node *node;
+	gpointer key, value;
+	GSList *l;
+
+	if (ril->notify_list == NULL)
+		return FALSE;
+
+	g_hash_table_iter_init(&iter, ril->notify_list);
+
+	while (g_hash_table_iter_next(&iter, &key, &value)) {
+		notify = value;
+
+		l = g_slist_find_custom(notify->nodes, GUINT_TO_POINTER(id),
+					ril_notify_node_compare_by_id);
+
+		if (l == NULL)
+			continue;
+
+		node = l->data;
+
+		if (node->gid != group)
+			return FALSE;
+
+		if (mark_only) {
+			node->destroyed = TRUE;
+			return TRUE;
+		}
+
+		ril_notify_node_destroy(node, NULL);
+		notify->nodes = g_slist_remove(notify->nodes, node);
+
+		if (notify->nodes == NULL)
+			g_hash_table_iter_remove(&iter);
+
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+GRil *g_ril_new()
+{
+	GRil *ril;
+
+	ril = g_try_new0(GRil, 1);
+	if (ril == NULL)
+		return NULL;
+
+	ril->parent = create_ril();
+	if (ril->parent == NULL) {
+		g_free(ril);
+		return NULL;
+	}
+
+	ril->group = ril->parent->next_gid++;
+	ril->ref_count = 1;
+
+	return ril;
+}
+
+GRil *g_ril_clone(GRil *clone)
+{
+	GRil *ril;
+
+	if (clone == NULL)
+		return NULL;
+
+	ril = g_try_new0(GRil, 1);
+	if (ril == NULL)
+		return NULL;
+
+	ril->parent = clone->parent;
+	ril->group = ril->parent->next_gid++;
+	ril->ref_count = 1;
+	g_atomic_int_inc(&ril->parent->ref_count);
+
+	return ril;
+}
+
+GIOChannel *g_ril_get_channel(GRil *ril)
+{
+	if (ril == NULL || ril->parent->io == NULL)
+ 		return NULL;
+
+	return g_ril_io_get_channel(ril->parent->io);
+
+}
+
+GRilIO *g_ril_get_io(GRil *ril)
+{
+	if (ril == NULL)
+		return NULL;
+
+	return ril->parent->io;
+}
+
+GRil *g_ril_ref(GRil *ril)
+{
+	if (ril == NULL)
+		return NULL;
+
+	g_atomic_int_inc(&ril->ref_count);
+
+	return ril;
+}
+
+guint g_ril_send(GRil *ril, const guint req, const char *data,
+			const gsize data_len, GRilResponseFunc func,
+			gpointer user_data, GDestroyNotify notify)
+{
+	struct ril_request *r;
+	struct ril_s *p;
+
+	if (ril == NULL || ril->parent == NULL || ril->parent->command_queue == NULL)
+		return 0;
+
+        p = ril->parent;
+
+	r = ril_request_create(p, ril->group, req, p->next_cmd_id,
+				data, data_len, func,
+				user_data, notify, FALSE);
+	if (r == NULL)
+		return 0;
+
+	p->next_cmd_id++;
+
+	g_queue_push_tail(p->command_queue, r);
+
+	if (g_queue_get_length(p->command_queue) == 1) {
+		DBG("calling wakeup_writer: qlen: %d", g_queue_get_length(p->command_queue));
+		ril_wakeup_writer(p);
+	}
+
+	return r->id;
+}
+
+void g_ril_suspend(GRil *ril)
+{
+	if (ril == NULL)
+		return;
+
+	ril_suspend(ril->parent);
+}
+
+void g_ril_resume(GRil *ril)
+{
+	if (ril == NULL)
+		return;
+
+	ril_resume(ril->parent);
+}
+
+void g_ril_unref(GRil *ril)
+{
+	gboolean is_zero;
+
+	if (ril == NULL)
+		return;
+
+	is_zero = g_atomic_int_dec_and_test(&ril->ref_count);
+
+	if (is_zero == FALSE)
+		return;
+
+	ril_unref(ril->parent);
+
+	g_free(ril);
+}
+
+gboolean g_ril_set_debug(GRil *ril,
+			GRilDebugFunc func, gpointer user_data)
+{
+
+	if (ril == NULL || ril->group != 0)
+		return FALSE;
+
+	return ril_set_debug(ril->parent, func, user_data);
+}
+
+guint g_ril_register(GRil *ril, const int req,
+			GRilNotifyFunc func, gpointer user_data)
+{
+	if (ril == NULL)
+		return 0;
+
+	return ril_register(ril->parent, ril->group, req,
+				func, user_data);
+}
+
+gboolean g_ril_unregister(GRil *ril, guint id)
+{
+	if (ril == NULL)
+		return FALSE;
+
+	return ril_unregister(ril->parent, ril->parent->in_notify,
+					ril->group, id);
+}
+
+gboolean g_ril_unregister_all(GRil *ril)
+{
+	if (ril == NULL)
+		return FALSE;
+
+	return ril_unregister_all(ril->parent,
+					ril->parent->in_notify,
+					node_compare_by_group,
+					GUINT_TO_POINTER(ril->group));
+}

=== added file 'gril/gril.h'
--- gril/gril.h	1970-01-01 00:00:00 +0000
+++ gril/gril.h	2013-04-09 20:01:20 +0000
@@ -0,0 +1,102 @@
+/*
+ *
+ *  RIL library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012 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 __GRIL_H
+#define __GRIL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "grilresponse.h"
+#include "grilutil.h"
+#include "grilio.h"
+#include "ril_constants.h"
+
+struct _GRil;
+
+typedef struct _GRil GRil;
+
+/*
+ * This struct represents an entire RIL message read
+ * from the command socket.  It can hold responses or
+ * unsolicited requests from RILD.
+ */
+struct ril_msg {
+	gchar *buf;
+	gsize buf_len;
+	gboolean unsolicited;
+	int req;
+	int serial_no;
+	int error;
+};
+
+typedef void (*GRilResponseFunc)(struct ril_msg *message, gpointer user_data);
+
+typedef void (*GRilNotifyFunc)(struct ril_msg *message, gpointer user_data);
+
+GRil *g_ril_new();
+
+GIOChannel *g_ril_get_channel(GRil *ril);
+GRilIO *g_ril_get_io(GRil *ril);
+
+GRil *g_ril_ref(GRil *ril);
+void g_ril_unref(GRil *ril);
+
+GRil *g_ril_clone(GRil *ril);
+
+void g_ril_suspend(GRil *ril);
+void g_ril_resume(GRil *ril);
+
+gboolean g_ril_set_disconnect_function(GRil *ril, GRilDisconnectFunc disconnect,
+					gpointer user_data);
+
+/*!
+ * If the function is not NULL, then on every read/write from the GIOChannel
+ * provided to GRil the logging function will be called with the
+ * input/output string and user data
+ */
+gboolean g_ril_set_debug(GRil *ril, GRilDebugFunc func, gpointer user_data);
+
+/*!
+ * Queue an RIL request for execution.  The request contents are given
+ * in data.  Once the command executes, the callback function given by
+ * func is called with user provided data in user_data.
+ *
+ * Returns an id of the queued command which can be canceled using
+ * g_ril_cancel.  If an error occurred, an id of 0 is returned.
+ *
+ */
+guint g_ril_send(GRil *ril, const guint req, const char *data, const gsize data_len,
+		GRilResponseFunc func, gpointer user_data, GDestroyNotify notify);
+
+guint g_ril_register(GRil *ril, const int req,
+			GRilNotifyFunc func, gpointer user_data);
+
+gboolean g_ril_unregister(GRil *ril, guint id);
+gboolean g_ril_unregister_all(GRil *ril);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GRIL_H */

=== added file 'gril/grilio.c'
--- gril/grilio.c	1970-01-01 00:00:00 +0000
+++ gril/grilio.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,396 @@
+/*
+ *
+ *  RIL chat library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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 <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include "ringbuffer.h"
+#include "grilio.h"
+#include "grilutil.h"
+
+struct _GRilIO {
+	gint ref_count;				/* Ref count */
+	guint read_watch;			/* GSource read id, 0 if no */
+	guint write_watch;			/* GSource write id, 0 if no */
+	GIOChannel *channel;			/* comms channel */
+	GRilDisconnectFunc user_disconnect;	/* user disconnect func */
+	gpointer user_disconnect_data;		/* user disconnect data */
+	struct ring_buffer *buf;		/* Current read buffer */
+	guint max_read_attempts;		/* max reads / select */
+	GRilIOReadFunc read_handler;		/* Read callback */
+	gpointer read_data;			/* Read callback userdata */
+	gboolean use_write_watch;		/* Use write select */
+	GRilIOWriteFunc write_handler;		/* Write callback */
+	gpointer write_data;			/* Write callback userdata */
+	GRilDebugFunc debugf;			/* debugging output function */
+	gpointer debug_data;			/* Data to pass to debug func */
+	GRilDisconnectFunc write_done_func;	/* tx empty notifier */
+	gpointer write_done_data;		/* tx empty data */
+	gboolean destroyed;			/* Re-entrancy guard */
+};
+
+static void read_watcher_destroy_notify(gpointer user_data)
+{
+	GRilIO *io = user_data;
+
+	ring_buffer_free(io->buf);
+	io->buf = NULL;
+
+	io->debugf = NULL;
+	io->debug_data = NULL;
+
+	io->read_watch = 0;
+	io->read_handler = NULL;
+	io->read_data = NULL;
+
+	io->channel = NULL;
+
+	if (io->destroyed)
+		g_free(io);
+	else if (io->user_disconnect)
+		io->user_disconnect(io->user_disconnect_data);
+}
+
+static gboolean received_data(GIOChannel *channel, GIOCondition cond,
+				gpointer data)
+{
+	unsigned char *buf;
+	GRilIO *io = data;
+	GIOStatus status;
+	gsize rbytes;
+	gsize toread;
+	gsize total_read = 0;
+	guint read_count = 0;
+
+	if (cond & G_IO_NVAL)
+		return FALSE;
+
+	/* Regardless of condition, try to read all the data available */
+	do {
+		toread = ring_buffer_avail_no_wrap(io->buf);
+
+		if (toread == 0)
+			break;
+
+		rbytes = 0;
+		buf = ring_buffer_write_ptr(io->buf, 0);
+
+		status = g_io_channel_read_chars(channel, (char *) buf,
+							toread, &rbytes, NULL);
+
+		g_ril_util_debug_hexdump(TRUE, (char *)buf, rbytes,
+						io->debugf, io->debug_data);
+
+		read_count++;
+
+		total_read += rbytes;
+
+		if (rbytes > 0)
+			ring_buffer_write_advance(io->buf, rbytes);
+
+	} while (status == G_IO_STATUS_NORMAL && rbytes > 0 &&
+					read_count < io->max_read_attempts);
+
+	if (total_read > 0 && io->read_handler)
+		io->read_handler(io->buf, io->read_data);
+
+	if (cond & (G_IO_HUP | G_IO_ERR))
+		return FALSE;
+
+	if (read_count > 0 && rbytes == 0 && status != G_IO_STATUS_AGAIN)
+		return FALSE;
+
+	/* We're overflowing the buffer, shutdown the socket */
+	if (ring_buffer_avail(io->buf) == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+gsize g_ril_io_write(GRilIO *io, const gchar *data, gsize count)
+{
+	GIOStatus status;
+	gsize bytes_written;
+
+	status = g_io_channel_write_chars(io->channel, data,
+						count, &bytes_written, NULL);
+
+	if (status != G_IO_STATUS_NORMAL) {
+		g_source_remove(io->read_watch);
+		return 0;
+	}
+
+	g_ril_util_debug_hexdump(FALSE, data, bytes_written,
+				io->debugf, io->debug_data);
+
+	return bytes_written;
+}
+
+static void write_watcher_destroy_notify(gpointer user_data)
+{
+	GRilIO *io = user_data;
+
+	io->write_watch = 0;
+	io->write_handler = NULL;
+	io->write_data = NULL;
+
+	if (io->write_done_func) {
+		io->write_done_func(io->write_done_data);
+		io->write_done_func = NULL;
+		io->write_done_data = NULL;
+	}
+}
+
+static gboolean can_write_data(GIOChannel *channel, GIOCondition cond,
+				gpointer data)
+{
+	GRilIO *io = data;
+
+	if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+		return FALSE;
+
+	if (io->write_handler == NULL)
+		return FALSE;
+
+	return io->write_handler(io->write_data);
+}
+
+static GRilIO *create_io(GIOChannel *channel, GIOFlags flags)
+{
+	GRilIO *io;
+
+	if (channel == NULL)
+		return NULL;
+
+	io = g_try_new0(GRilIO, 1);
+	if (io == NULL)
+		return io;
+
+	io->ref_count = 1;
+	io->debugf = NULL;
+
+	if (flags & G_IO_FLAG_NONBLOCK) {
+		io->max_read_attempts = 3;
+		io->use_write_watch = TRUE;
+	} else {
+		io->max_read_attempts = 1;
+		io->use_write_watch = FALSE;
+	}
+
+	io->buf = ring_buffer_new(8192);
+
+	if (!io->buf)
+		goto error;
+
+	if (!g_ril_util_setup_io(channel, flags))
+		goto error;
+
+	io->channel = channel;
+	io->read_watch = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT,
+				G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+				received_data, io,
+				read_watcher_destroy_notify);
+
+	return io;
+
+error:
+	if (io->buf)
+		ring_buffer_free(io->buf);
+
+	g_free(io);
+
+	return NULL;
+}
+
+GRilIO *g_ril_io_new(GIOChannel *channel)
+{
+	return create_io(channel, G_IO_FLAG_NONBLOCK);
+}
+
+GRilIO *g_ril_io_new_blocking(GIOChannel *channel)
+{
+	return create_io(channel, 0);
+}
+
+GIOChannel *g_ril_io_get_channel(GRilIO *io)
+{
+	if (io == NULL)
+		return NULL;
+
+	return io->channel;
+}
+
+gboolean g_ril_io_set_read_handler(GRilIO *io, GRilIOReadFunc read_handler,
+					gpointer user_data)
+{
+	if (io == NULL)
+		return FALSE;
+
+	io->read_handler = read_handler;
+	io->read_data = user_data;
+
+	if (read_handler && ring_buffer_len(io->buf) > 0)
+		read_handler(io->buf, user_data);
+
+	return TRUE;
+}
+
+static gboolean call_blocking_read(gpointer user_data)
+{
+	GRilIO *io = user_data;
+
+	while (can_write_data(io->channel, G_IO_OUT, io) == TRUE);
+	write_watcher_destroy_notify(io);
+
+	return FALSE;
+}
+
+gboolean g_ril_io_set_write_handler(GRilIO *io, GRilIOWriteFunc write_handler,
+					gpointer user_data)
+{
+	if (io == NULL)
+		return FALSE;
+
+	if (io->write_watch > 0) {
+		if (write_handler == NULL) {
+			g_source_remove(io->write_watch);
+			return TRUE;
+		}
+
+		return FALSE;
+	}
+
+	if (write_handler == NULL)
+		return FALSE;
+
+	io->write_handler = write_handler;
+	io->write_data = user_data;
+
+	if (io->use_write_watch == TRUE)
+		io->write_watch = g_io_add_watch_full(io->channel,
+				G_PRIORITY_HIGH,
+				G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+				can_write_data, io,
+				write_watcher_destroy_notify);
+	else
+		io->write_watch = g_idle_add(call_blocking_read, io);
+
+	return TRUE;
+}
+
+GRilIO *g_ril_io_ref(GRilIO *io)
+{
+	if (io == NULL)
+		return NULL;
+
+	g_atomic_int_inc(&io->ref_count);
+
+	return io;
+}
+
+static gboolean io_shutdown(GRilIO *io)
+{
+	/* Don't trigger user disconnect on shutdown */
+	io->user_disconnect = NULL;
+	io->user_disconnect_data = NULL;
+
+	if (io->read_watch > 0)
+		g_source_remove(io->read_watch);
+
+	if (io->write_watch > 0)
+		g_source_remove(io->write_watch);
+
+	return TRUE;
+}
+
+void g_ril_io_unref(GRilIO *io)
+{
+	gboolean is_zero;
+
+	if (io == NULL)
+		return;
+
+	is_zero = g_atomic_int_dec_and_test(&io->ref_count);
+
+	if (is_zero == FALSE)
+		return;
+
+	io_shutdown(io);
+
+	/* glib delays the destruction of the watcher until it exits, this
+	 * means we can't free the data just yet, even though we've been
+	 * destroyed already.  We have to wait until the read_watcher
+	 * destroy function gets called
+	 */
+	if (io->read_watch > 0)
+		io->destroyed = TRUE;
+	else
+		g_free(io);
+}
+
+gboolean g_ril_io_set_disconnect_function(GRilIO *io,
+			GRilDisconnectFunc disconnect, gpointer user_data)
+{
+	if (io == NULL)
+		return FALSE;
+
+	io->user_disconnect = disconnect;
+	io->user_disconnect_data = user_data;
+
+	return TRUE;
+}
+
+gboolean g_ril_io_set_debug(GRilIO *io, GRilDebugFunc func, gpointer user_data)
+{
+	if (io == NULL)
+		return FALSE;
+
+	io->debugf = func;
+	io->debug_data = user_data;
+
+	return TRUE;
+}
+
+void g_ril_io_set_write_done(GRilIO *io, GRilDisconnectFunc func,
+				gpointer user_data)
+{
+	if (io == NULL)
+		return;
+
+	io->write_done_func = func;
+	io->write_done_data = user_data;
+}
+
+void g_ril_io_drain_ring_buffer(GRilIO *io, guint len)
+{
+	ring_buffer_drain(io->buf, len);
+}

=== added file 'gril/grilio.h'
--- gril/grilio.h	1970-01-01 00:00:00 +0000
+++ gril/grilio.h	2013-04-09 20:01:20 +0000
@@ -0,0 +1,69 @@
+/*
+ *
+ *  RIL chat library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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 __GRILIO_H
+#define __GRILIO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "gfunc.h"
+
+struct _GRilIO;
+
+typedef struct _GRilIO GRilIO;
+
+struct ring_buffer;
+
+typedef void (*GRilIOReadFunc)(struct ring_buffer *buffer, gpointer user_data);
+typedef gboolean (*GRilIOWriteFunc)(gpointer user_data);
+
+GRilIO *g_ril_io_new(GIOChannel *channel);
+GRilIO *g_ril_io_new_blocking(GIOChannel *channel);
+
+GIOChannel *g_ril_io_get_channel(GRilIO *io);
+
+GRilIO *g_ril_io_ref(GRilIO *io);
+void g_ril_io_unref(GRilIO *io);
+
+gboolean g_ril_io_set_read_handler(GRilIO *io, GRilIOReadFunc read_handler,
+					gpointer user_data);
+gboolean g_ril_io_set_write_handler(GRilIO *io, GRilIOWriteFunc write_handler,
+					gpointer user_data);
+void g_ril_io_set_write_done(GRilIO *io, GRilDisconnectFunc func,
+				gpointer user_data);
+
+void g_ril_io_drain_ring_buffer(GRilIO *io, guint len);
+
+gsize g_ril_io_write(GRilIO *io, const gchar *data, gsize count);
+
+gboolean g_ril_io_set_disconnect_function(GRilIO *io,
+			GRilDisconnectFunc disconnect, gpointer user_data);
+
+gboolean g_ril_io_set_debug(GRilIO *io, GRilDebugFunc func, gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GRILIO_H */

=== added file 'gril/grilresponse.h'
--- gril/grilresponse.h	1970-01-01 00:00:00 +0000
+++ gril/grilresponse.h	2013-04-09 20:01:20 +0000
@@ -0,0 +1,46 @@
+/*
+ *
+ *  RIL chat library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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 __GRIL_RESPONSE_H
+#define __GRIL_RESPONSE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _GRilResponse {
+	GSList *lines;
+	char *final_or_pdu;
+};
+
+typedef struct _GRilResponse GRilResponse;
+
+#define G_RIL_RESPONSE_LINE_LENGTH_MAX 2048
+
+const char *g_ril_final_response(GRilResponse *response);
+const char *g_ril_response_pdu(GRilResponse *response);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GRIL_RESPONSE_H */

=== added file 'gril/grilutil.c'
--- gril/grilutil.c	1970-01-01 00:00:00 +0000
+++ gril/grilutil.c	2013-04-09 20:01:20 +0000
@@ -0,0 +1,499 @@
+/*
+ *
+ *  RIL library with GLib integration
+ *
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2012  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 <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include "grilutil.h"
+#include "ril_constants.h"
+
+const char *ril_appstate_to_string(int app_state)
+{
+	switch (app_state) {
+	case RIL_APPSTATE_UNKNOWN:
+		return "UNKNOWN";
+	case RIL_APPSTATE_DETECTED:
+		return "DETECTED";
+	case RIL_APPSTATE_PIN:
+		return "PIN";
+	case RIL_APPSTATE_PUK:
+		return "PUK";
+	case RIL_APPSTATE_SUBSCRIPTION_PERSO:
+		return "";
+	case RIL_APPSTATE_READY:
+		return "READY";
+	default:
+		return "<INVALID>";
+	}
+}
+
+const char *ril_apptype_to_string(int app_type)
+{
+
+	switch (app_type) {
+	case RIL_APPTYPE_UNKNOWN:
+		return "UNKNOWN";
+	case RIL_APPTYPE_SIM:
+		return "SIM";
+	case RIL_APPTYPE_USIM:
+		return "USIM";
+	case RIL_APPTYPE_RUIM:
+		return "RUIM";
+	case RIL_APPTYPE_CSIM:
+		return "CSIM";
+	case RIL_APPTYPE_ISIM:
+		return "ISIM";
+	default:
+		return "<INVALID>";
+	}
+}
+
+const char *ril_cardstate_to_string(int card_state)
+{
+	switch (card_state) {
+	case RIL_CARDSTATE_ABSENT:
+		return "ABSENT";
+	case RIL_CARDSTATE_PRESENT:
+		return "PRESENT";
+	case RIL_CARDSTATE_ERROR:
+		return "ERROR";
+	default:
+		return "<INVALID>";
+	}
+}
+
+const char *ril_pinstate_to_string(int pin_state)
+{
+	switch (pin_state) {
+	case RIL_PINSTATE_UNKNOWN:
+		return "UNKNOWN";
+	case RIL_PINSTATE_ENABLED_NOT_VERIFIED:
+		return "ENABLED_NOT_VERIFIED";
+	case RIL_PINSTATE_ENABLED_VERIFIED:
+		return "ENABLED_VERIFIED";
+	case RIL_PINSTATE_DISABLED:
+		return "DISABLED";
+	case RIL_PINSTATE_ENABLED_BLOCKED:
+		return "ENABLED_BLOCKED";
+	case RIL_PINSTATE_ENABLED_PERM_BLOCKED:
+		return "ENABLED_PERM_BLOCKED";
+	default:
+		return "<INVALID>";
+	}
+}
+
+const char *ril_request_id_to_string(int req)
+{
+	switch (req) {
+	case RIL_REQUEST_GET_SIM_STATUS:
+		return "RIL_REQUEST_GET_SIM_STATUS";
+	case RIL_REQUEST_ENTER_SIM_PIN:
+		return "RIL_REQUEST_ENTER_SIM_PIN";
+	case RIL_REQUEST_ENTER_SIM_PUK:
+		return "RIL_REQUEST_ENTER_SIM_PUK";
+	case RIL_REQUEST_ENTER_SIM_PIN2:
+		return "RIL_REQUEST_ENTER_SIM_PIN2";
+	case RIL_REQUEST_ENTER_SIM_PUK2:
+		return "RIL_REQUEST_ENTER_SIM_PUK2";
+	case RIL_REQUEST_CHANGE_SIM_PIN:
+		return "RIL_REQUEST_CHANGE_SIM_PIN";
+	case RIL_REQUEST_CHANGE_SIM_PIN2:
+		return "RIL_REQUEST_CHANGE_SIM_PIN2";
+	case RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION:
+		return "RIL_REQUEST_ENTER_NETWORK_DEPERSONALIZATION";
+	case RIL_REQUEST_GET_CURRENT_CALLS:
+		return "RIL_REQUEST_GET_CURRENT_CALLS";
+	case RIL_REQUEST_DIAL:
+		return "RIL_REQUEST_DIAL";
+	case RIL_REQUEST_GET_IMSI:
+		return "RIL_REQUEST_GET_IMSI";
+	case RIL_REQUEST_HANGUP:
+		return "RIL_REQUEST_HANGUP";
+	case RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND:
+		return "RIL_REQUEST_HANGUP_WAITING_OR_BACKGROUND";
+	case RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND:
+		return "RIL_REQUEST_HANGUP_FOREGROUND_RESUME_BACKGROUND";
+	case RIL_REQUEST_SWITCH_HOLDING_AND_ACTIVE:
+		return "RIL_REQUEST_SWITCH_HOLDING_AND_ACTIVE";
+	case RIL_REQUEST_CONFERENCE:
+		return "RIL_REQUEST_CONFERENCE";
+	case RIL_REQUEST_UDUB:
+		return "RIL_REQUEST_UDUB";
+	case RIL_REQUEST_LAST_CALL_FAIL_CAUSE:
+		return "RIL_REQUEST_LAST_CALL_FAIL_CAUSE";
+	case RIL_REQUEST_SIGNAL_STRENGTH:
+		return "RIL_REQUEST_SIGNAL_STRENGTH";
+	case RIL_REQUEST_VOICE_REGISTRATION_STATE:
+		return "RIL_REQUEST_VOICE_REGISTRATION_STATE";
+	case RIL_REQUEST_DATA_REGISTRATION_STATE:
+		return "RIL_REQUEST_DATA_REGISTRATION_STATE";
+	case RIL_REQUEST_OPERATOR:
+		return "RIL_REQUEST_OPERATOR";
+	case RIL_REQUEST_RADIO_POWER:
+		return "RIL_REQUEST_RADIO_POWER";
+	case RIL_REQUEST_DTMF:
+		return "RIL_REQUEST_DTMF";
+	case RIL_REQUEST_SEND_SMS:
+		return "RIL_REQUEST_SEND_SMS";
+	case RIL_REQUEST_SEND_SMS_EXPECT_MORE:
+		return "RIL_REQUEST_SEND_SMS_EXPECT_MORE";
+	case RIL_REQUEST_SETUP_DATA_CALL:
+		return "RIL_REQUEST_SETUP_DATA_CALL";
+	case RIL_REQUEST_SIM_IO:
+		return "RIL_REQUEST_SIM_IO";
+	case RIL_REQUEST_SEND_USSD:
+		return "RIL_REQUEST_SEND_USSD";
+	case RIL_REQUEST_CANCEL_USSD:
+		return "RIL_REQUEST_CANCEL_USSD";
+	case RIL_REQUEST_GET_CLIR:
+		return "RIL_REQUEST_GET_CLIR";
+	case RIL_REQUEST_SET_CLIR:
+		return "RIL_REQUEST_SET_CLIR";
+	case RIL_REQUEST_QUERY_CALL_FORWARD_STATUS:
+		return "RIL_REQUEST_QUERY_CALL_FORWARD_STATUS";
+	case RIL_REQUEST_SET_CALL_FORWARD:
+		return "RIL_REQUEST_SET_CALL_FORWARD";
+	case RIL_REQUEST_QUERY_CALL_WAITING:
+		return "RIL_REQUEST_QUERY_CALL_WAITING";
+	case RIL_REQUEST_SET_CALL_WAITING:
+		return "RIL_REQUEST_SET_CALL_WAITING";
+	case RIL_REQUEST_SMS_ACKNOWLEDGE :
+		return "RIL_REQUEST_SMS_ACKNOWLEDGE ";
+	case RIL_REQUEST_GET_IMEI:
+		return "RIL_REQUEST_GET_IMEI";
+	case RIL_REQUEST_GET_IMEISV:
+		return "RIL_REQUEST_GET_IMEISV";
+	case RIL_REQUEST_ANSWER:
+		return "RIL_REQUEST_ANSWER";
+	case RIL_REQUEST_DEACTIVATE_DATA_CALL:
+		return "RIL_REQUEST_DEACTIVATE_DATA_CALL";
+	case RIL_REQUEST_QUERY_FACILITY_LOCK:
+		return "RIL_REQUEST_QUERY_FACILITY_LOCK";
+	case RIL_REQUEST_SET_FACILITY_LOCK:
+		return "RIL_REQUEST_SET_FACILITY_LOCK";
+	case RIL_REQUEST_CHANGE_BARRING_PASSWORD:
+		return "RIL_REQUEST_CHANGE_BARRING_PASSWORD";
+	case RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE:
+		return "RIL_REQUEST_QUERY_NETWORK_SELECTION_MODE";
+	case RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC:
+		return "RIL_REQUEST_SET_NETWORK_SELECTION_AUTOMATIC";
+	case RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL:
+		return "RIL_REQUEST_SET_NETWORK_SELECTION_MANUAL";
+	case RIL_REQUEST_QUERY_AVAILABLE_NETWORKS:
+		return "RIL_REQUEST_QUERY_AVAILABLE_NETWORKS";
+	case RIL_REQUEST_DTMF_START:
+		return "RIL_REQUEST_DTMF_START";
+	case RIL_REQUEST_DTMF_STOP:
+		return "RIL_REQUEST_DTMF_STOP";
+	case RIL_REQUEST_BASEBAND_VERSION:
+		return "RIL_REQUEST_BASEBAND_VERSION";
+	case RIL_REQUEST_SEPARATE_CONNECTION:
+		return "RIL_REQUEST_SEPARATE_CONNECTION";
+	case RIL_REQUEST_SET_MUTE:
+		return "RIL_REQUEST_SET_MUTE";
+	case RIL_REQUEST_GET_MUTE:
+		return "RIL_REQUEST_GET_MUTE";
+	case RIL_REQUEST_QUERY_CLIP:
+		return "RIL_REQUEST_QUERY_CLIP";
+	case RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE:
+		return "RIL_REQUEST_LAST_DATA_CALL_FAIL_CAUSE";
+	case RIL_REQUEST_DATA_CALL_LIST:
+		return "RIL_REQUEST_DATA_CALL_LIST";
+	case RIL_REQUEST_RESET_RADIO:
+		return "RIL_REQUEST_RESET_RADIO";
+	case RIL_REQUEST_OEM_HOOK_RAW:
+		return "RIL_REQUEST_OEM_HOOK_RAW";
+	case RIL_REQUEST_OEM_HOOK_STRINGS:
+		return "RIL_REQUEST_OEM_HOOK_STRINGS";
+	case RIL_REQUEST_SCREEN_STATE:
+		return "RIL_REQUEST_SCREEN_STATE";
+	case RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION:
+		return "RIL_REQUEST_SET_SUPP_SVC_NOTIFICATION";
+	case RIL_REQUEST_WRITE_SMS_TO_SIM:
+		return "RIL_REQUEST_WRITE_SMS_TO_SIM";
+	case RIL_REQUEST_DELETE_SMS_ON_SIM:
+		return "RIL_REQUEST_DELETE_SMS_ON_SIM";
+	case RIL_REQUEST_SET_BAND_MODE:
+		return "RIL_REQUEST_SET_BAND_MODE";
+	case RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE:
+		return "RIL_REQUEST_QUERY_AVAILABLE_BAND_MODE";
+	case RIL_REQUEST_STK_GET_PROFILE:
+		return "RIL_REQUEST_STK_GET_PROFILE";
+	case RIL_REQUEST_STK_SET_PROFILE:
+		return "RIL_REQUEST_STK_SET_PROFILE";
+	case RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND:
+		return "RIL_REQUEST_STK_SEND_ENVELOPE_COMMAND";
+	case RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE:
+		return "RIL_REQUEST_STK_SEND_TERMINAL_RESPONSE";
+	case RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM:
+		return "RIL_REQUEST_STK_HANDLE_CALL_SETUP_REQUESTED_FROM_SIM";
+	case RIL_REQUEST_EXPLICIT_CALL_TRANSFER:
+		return "RIL_REQUEST_EXPLICIT_CALL_TRANSFER";
+	case RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE:
+		return "RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE";
+	case RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE:
+		return "RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE";
+	case RIL_REQUEST_GET_NEIGHBORING_CELL_IDS:
+		return "RIL_REQUEST_GET_NEIGHBORING_CELL_IDS";
+	case RIL_REQUEST_SET_LOCATION_UPDATES:
+		return "RIL_REQUEST_SET_LOCATION_UPDATES";
+	case RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE:
+		return "RIL_REQUEST_CDMA_SET_SUBSCRIPTION_SOURCE";
+	case RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE:
+		return "RIL_REQUEST_CDMA_SET_ROAMING_PREFERENCE";
+	case RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE:
+		return "RIL_REQUEST_CDMA_QUERY_ROAMING_PREFERENCE";
+	case RIL_REQUEST_SET_TTY_MODE:
+		return "RIL_REQUEST_SET_TTY_MODE";
+	case RIL_REQUEST_QUERY_TTY_MODE:
+		return "RIL_REQUEST_QUERY_TTY_MODE";
+	case RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE:
+		return "RIL_REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE";
+	case RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE:
+		return "RIL_REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE";
+	case RIL_REQUEST_CDMA_FLASH:
+		return "RIL_REQUEST_CDMA_FLASH";
+	case RIL_REQUEST_CDMA_BURST_DTMF:
+		return "RIL_REQUEST_CDMA_BURST_DTMF";
+	case RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY:
+		return "RIL_REQUEST_CDMA_VALIDATE_AND_WRITE_AKEY";
+	case RIL_REQUEST_CDMA_SEND_SMS:
+		return "RIL_REQUEST_CDMA_SEND_SMS";
+	case RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE:
+		return "RIL_REQUEST_CDMA_SMS_ACKNOWLEDGE";
+	case RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG:
+		return "RIL_REQUEST_GSM_GET_BROADCAST_SMS_CONFIG";
+	case RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG:
+		return "RIL_REQUEST_GSM_SET_BROADCAST_SMS_CONFIG";
+	case RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION:
+		return "RIL_REQUEST_GSM_SMS_BROADCAST_ACTIVATION";
+	case RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG:
+		return "RIL_REQUEST_CDMA_GET_BROADCAST_SMS_CONFIG";
+	case RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG:
+		return "RIL_REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG";
+	case RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION:
+		return "RIL_REQUEST_CDMA_SMS_BROADCAST_ACTIVATION";
+	case RIL_REQUEST_CDMA_SUBSCRIPTION:
+		return "RIL_REQUEST_CDMA_SUBSCRIPTION";
+	case RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM:
+		return "RIL_REQUEST_CDMA_WRITE_SMS_TO_RUIM";
+	case RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM:
+		return "RIL_REQUEST_CDMA_DELETE_SMS_ON_RUIM";
+	case RIL_REQUEST_DEVICE_IDENTITY:
+		return "RIL_REQUEST_DEVICE_IDENTITY";
+	case RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE:
+		return "RIL_REQUEST_EXIT_EMERGENCY_CALLBACK_MODE";
+	case RIL_REQUEST_GET_SMSC_ADDRESS:
+		return "RIL_REQUEST_GET_SMSC_ADDRESS";
+	case RIL_REQUEST_SET_SMSC_ADDRESS:
+		return "RIL_REQUEST_SET_SMSC_ADDRESS";
+	case RIL_REQUEST_REPORT_SMS_MEMORY_STATUS:
+		return "RIL_REQUEST_REPORT_SMS_MEMORY_STATUS";
+	case RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING:
+		return "RIL_REQUEST_REPORT_STK_SERVICE_IS_RUNNING";
+	case RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE:
+		return "RIL_REQUEST_CDMA_GET_SUBSCRIPTION_SOURCE";
+	case RIL_REQUEST_ISIM_AUTHENTICATION:
+		return "RIL_REQUEST_ISIM_AUTHENTICATION";
+	case RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU:
+		return "RIL_REQUEST_ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU";
+	case RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS:
+		return "RIL_REQUEST_STK_SEND_ENVELOPE_WITH_STATUS";
+	default:
+		return "<INVALID>";
+	}
+}
+
+void g_ril_util_debug_chat(gboolean in, const char *str, gsize len,
+				GRilDebugFunc debugf, gpointer user_data)
+{
+	char type = in ? '<' : '>';
+	gsize escaped = 2; /* Enough for '<', ' ' */
+	char *escaped_str;
+	const char *esc = "<ESC>";
+	gsize esc_size = strlen(esc);
+	const char *ctrlz = "<CtrlZ>";
+	gsize ctrlz_size = strlen(ctrlz);
+	gsize i;
+
+	if (debugf == NULL || !len)
+		return;
+
+	for (i = 0; i < len; i++) {
+		char c = str[i];
+
+		if (g_ascii_isprint(c))
+			escaped += 1;
+		else if (c == '\r' || c == '\t' || c == '\n')
+			escaped += 2;
+		else if (c == 26)
+			escaped += ctrlz_size;
+		else if (c == 25)
+			escaped += esc_size;
+		else
+			escaped += 4;
+	}
+
+	escaped_str = g_try_malloc(escaped + 1);
+	if (escaped_str == NULL)
+		return;
+
+	escaped_str[0] = type;
+	escaped_str[1] = ' ';
+	escaped_str[2] = '\0';
+	escaped_str[escaped] = '\0';
+
+	for (escaped = 2, i = 0; i < len; i++) {
+		unsigned char c = str[i];
+
+		switch (c) {
+		case '\r':
+			escaped_str[escaped++] = '\\';
+			escaped_str[escaped++] = 'r';
+			break;
+		case '\t':
+			escaped_str[escaped++] = '\\';
+			escaped_str[escaped++] = 't';
+			break;
+		case '\n':
+			escaped_str[escaped++] = '\\';
+			escaped_str[escaped++] = 'n';
+			break;
+		case 26:
+			strncpy(&escaped_str[escaped], ctrlz, ctrlz_size);
+			escaped += ctrlz_size;
+			break;
+		case 25:
+			strncpy(&escaped_str[escaped], esc, esc_size);
+			escaped += esc_size;
+			break;
+		default:
+			if (g_ascii_isprint(c))
+				escaped_str[escaped++] = c;
+			else {
+				escaped_str[escaped++] = '\\';
+				escaped_str[escaped++] = '0' + ((c >> 6) & 07);
+				escaped_str[escaped++] = '0' + ((c >> 3) & 07);
+				escaped_str[escaped++] = '0' + (c & 07);