build: move source code under src/

29 files changed, 11181 insertions, 0 deletions

diff --git a/src/libqmi-glib/Makefile.am b/src/libqmi-glib/Makefile.am
new file mode 100644
index 0000000..bb958a1
--- /dev/null
+++ b/src/libqmi-glib/Makefile.am
@@ -0,0 +1,63 @@
+
+SUBDIRS = generated . test
+
+lib_LTLIBRARIES = libqmi-glib.la
+
+libqmi_glib_la_CPPFLAGS = \
+	$(LIBQMI_GLIB_CFLAGS) \
+	-I$(top_srcdir) \
+	-I$(top_builddir) \
+	-I$(top_srcdir)/src/libqmi-glib \
+	-I$(top_srcdir)/src/libqmi-glib/generated \
+	-I$(top_builddir)/src/libqmi-glib \
+	-I$(top_builddir)/src/libqmi-glib/generated \
+	-DLIBQMI_GLIB_COMPILATION \
+	-DG_LOG_DOMAIN=\"Qmi\"
+
+libqmi_glib_la_SOURCES = \
+	libqmi-glib.h \
+	qmi-version.h \
+	qmi-errors.h \
+	qmi-enums-wds.h qmi-enums-wds.c \
+	qmi-enums-dms.h qmi-flags64-dms.h \
+	qmi-enums-nas.h qmi-flags64-nas.h\
+	qmi-enums-wms.h \
+	qmi-enums-pds.h \
+	qmi-enums-pbm.h \
+	qmi-enums-uim.h \
+	qmi-enums-oma.h \
+	qmi-enums.h qmi-enums-private.h \
+	qmi-utils.h qmi-utils.c \
+	qmi-message.h qmi-message.c \
+	qmi-device.h qmi-device.c \
+	qmi-client.h qmi-client.c
+
+libqmi_glib_la_LIBADD = \
+	${top_builddir}/src/libqmi-glib/generated/libqmi-glib-generated.la \
+	$(LIBQMI_GLIB_LIBS)
+
+libqmi_glib_la_LDFLAGS = \
+	-version-info $(QMI_GLIB_LT_CURRENT):$(QMI_GLIB_LT_REVISION):$(QMI_GLIB_LT_AGE)
+
+includedir = @includedir@/libqmi-glib
+include_HEADERS = \
+	libqmi-glib.h \
+	qmi-version.h \
+	qmi-errors.h \
+	qmi-enums.h \
+	qmi-enums-private.h \
+	qmi-enums-dms.h qmi-flags64-dms.h \
+	qmi-enums-wds.h \
+	qmi-enums-nas.h qmi-flags64-nas.h \
+	qmi-enums-wms.h \
+	qmi-enums-pds.h \
+	qmi-enums-pbm.h \
+	qmi-enums-uim.h \
+	qmi-enums-oma.h \
+	qmi-utils.h \
+	qmi-message.h \
+	qmi-device.h \
+	qmi-client.h
+
+EXTRA_DIST = \
+	qmi-version.h.in
diff --git a/src/libqmi-glib/generated/Makefile.am b/src/libqmi-glib/generated/Makefile.am
new file mode 100644
index 0000000..6701bf9
--- /dev/null
+++ b/src/libqmi-glib/generated/Makefile.am
@@ -0,0 +1,243 @@
+
+noinst_LTLIBRARIES = libqmi-glib-generated.la
+
+GENERATED_H = \
+	qmi-error-types.h \
+	qmi-enum-types.h \
+	qmi-enum-types-private.h \
+	qmi-flags64-types.h \
+	qmi-ctl.h \
+	qmi-dms.h \
+	qmi-nas.h \
+	qmi-wds.h \
+	qmi-wms.h \
+	qmi-pds.h \
+	qmi-pbm.h \
+	qmi-uim.h \
+	qmi-oma.h
+
+GENERATED_C = \
+	qmi-error-types.c \
+	qmi-error-quarks.c \
+	qmi-enum-types.c \
+	qmi-enum-types-private.c \
+	qmi-flags64-types.c \
+	qmi-ctl.c \
+	qmi-dms.c \
+	qmi-nas.c \
+	qmi-wds.c \
+	qmi-wms.c \
+	qmi-pds.c \
+	qmi-pbm.c \
+	qmi-uim.c \
+	qmi-oma.c
+
+GENERATED_SECTIONS = \
+	qmi-ctl.sections \
+	qmi-dms.sections \
+	qmi-nas.sections \
+	qmi-wds.sections \
+	qmi-wms.sections \
+	qmi-pds.sections \
+	qmi-pbm.sections \
+	qmi-uim.sections \
+	qmi-oma.sections
+
+# Error types
+qmi-error-types.h: $(top_srcdir)/src/libqmi-glib/qmi-errors.h $(top_srcdir)/build-aux/templates/qmi-error-types-template.h
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#ifndef __LIBQMI_GLIB_ERROR_TYPES_H__\n#define __LIBQMI_GLIB_ERROR_TYPES_H__\n#include \"qmi-errors.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-error-types-template.h \
+		--ftail "#endif /* __LIBQMI_GLIB_ERROR_TYPES_H__ */\n" \
+		$(top_srcdir)/src/libqmi-glib/qmi-errors.h > $@
+
+qmi-error-types.c: $(top_srcdir)/src/libqmi-glib/qmi-errors.h qmi-error-types.h $(top_srcdir)/build-aux/templates/qmi-error-types-template.c
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#include \"qmi-errors.h\"\n#include \"qmi-error-types.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-error-types-template.c \
+		$(top_srcdir)/src/libqmi-glib/qmi-errors.h > $@
+
+qmi-error-quarks.c: $(top_srcdir)/src/libqmi-glib/qmi-errors.h qmi-error-types.h $(top_srcdir)/build-aux/templates/qmi-error-quarks-template.c
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#include \"qmi-errors.h\"\n#include \"qmi-error-types.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-error-quarks-template.c \
+		$(top_srcdir)/src/libqmi-glib/qmi-errors.h > $@
+
+# Enum/Flag types
+ENUMS = \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-wds.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-dms.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-nas.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-wms.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-pds.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-pbm.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-uim.h \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-oma.h
+qmi-enum-types.h:  $(ENUMS) $(top_srcdir)/build-aux/templates/qmi-enum-types-template.h
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#ifndef __LIBQMI_GLIB_ENUM_TYPES_H__\n#define __LIBQMI_GLIB_ENUM_TYPES_H__\n#include \"qmi-enums.h\"\n#include \"qmi-enums-wds.h\"\n#include \"qmi-enums-dms.h\"\n#include \"qmi-enums-nas.h\"\n#include \"qmi-enums-wms.h\"\n#include \"qmi-enums-pds.h\"\n#include \"qmi-enums-pbm.h\"\n#include \"qmi-enums-uim.h\"\n#include \"qmi-enums-oma.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-enum-types-template.h \
+		--ftail "#endif /* __LIBQMI_GLIB_ENUM_TYPES_H__ */\n" \
+		$(ENUMS) > $@
+
+qmi-enum-types.c: $(ENUMS) qmi-enum-types.h $(top_srcdir)/build-aux/templates/qmi-enum-types-template.c
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#include \"qmi-enum-types.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-enum-types-template.c \
+		$(ENUMS) > $@
+
+# Private Enum/Flag types
+PRIVATE_ENUMS = \
+	$(top_srcdir)/src/libqmi-glib/qmi-enums-private.h
+qmi-enum-types-private.h:  $(PRIVATE_ENUMS) $(top_srcdir)/build-aux/templates/qmi-enum-types-template.h
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#ifndef __LIBQMI_GLIB_ENUM_TYPES_PRIVATE_H__\n#define __LIBQMI_GLIB_ENUM_TYPES_PRIVATE_H__\n#include \"qmi-enums-private.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-enum-types-template.h \
+		--ftail "#endif /* __LIBQMI_GLIB_ENUM_TYPES_PRIVATE_H__ */\n" \
+		$(PRIVATE_ENUMS) > $@
+
+qmi-enum-types-private.c: $(PRIVATE_ENUMS) qmi-enum-types-private.h $(top_srcdir)/build-aux/templates/qmi-enum-types-template.c
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#include \"qmi-enum-types-private.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-enum-types-template.c \
+		$(PRIVATE_ENUMS) > $@
+
+# 64bit flag types
+FLAGS64 = $(top_srcdir)/src/libqmi-glib/qmi-flags64-dms.h $(top_srcdir)/src/libqmi-glib/qmi-flags64-nas.h
+qmi-flags64-types.h:  $(FLAGS64) $(top_srcdir)/build-aux/templates/qmi-flags64-types-template.h
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#ifndef __LIBQMI_GLIB_FLAGS64_TYPES_H__\n#define __LIBQMI_GLIB_FLAGS64_TYPES_H__\n#include \"qmi-flags64-dms.h\"\n#include \"qmi-flags64-nas.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-flags64-types-template.h \
+		--ftail "#endif /* __LIBQMI_GLIB_FLAGS64_TYPES_H__ */\n" \
+		$(FLAGS64) > $@
+
+qmi-flags64-types.c: $(FLAGS64) qmi-flags64-types.h $(top_srcdir)/build-aux/templates/qmi-flags64-types-template.c
+	$(AM_V_GEN) $(GLIB_MKENUMS) \
+		--fhead "#include \"qmi-flags64-types.h\"\n" \
+		--template $(top_srcdir)/build-aux/templates/qmi-flags64-types-template.c \
+		$(FLAGS64) > $@
+
+# CTL service
+qmi-ctl.h qmi-ctl.c qmi-ctl.sections: $(top_srcdir)/data/qmi-service-ctl.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN)  \
+		rm -f qmi-ctl.h && \
+		rm -f qmi-ctl.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-ctl.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-ctl
+
+# DMS service
+qmi-dms.h qmi-dms.c qmi-dms.sections: $(top_srcdir)/data/qmi-service-dms.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-dms.h && \
+		rm -f qmi-dms.c && \
+		 $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-dms.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-dms
+
+# WDS service
+qmi-wds.h qmi-wds.c qmi-wds.sections: $(top_srcdir)/data/qmi-service-wds.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-wds.h && \
+		rm -f qmi-wds.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-wds.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-wds
+
+# NAS service
+qmi-nas.h qmi-nas.c qmi-nas.sections: $(top_srcdir)/data/qmi-service-nas.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-nas.h && \
+		rm -f qmi-nas.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-nas.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-nas
+
+# WMS service
+qmi-wms.h qmi-wms.c qmi-wms.sections: $(top_srcdir)/data/qmi-service-wms.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-wms.h && \
+		rm -f qmi-wms.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-wms.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-wms
+
+# PDS service
+qmi-pds.h qmi-pds.c qmi-pds.sections: $(top_srcdir)/data/qmi-service-pds.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-pds.h && \
+		rm -f qmi-pds.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-pds.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-pds
+
+# PBM service
+qmi-pbm.h qmi-pbm.c qmi-pbm.sections: $(top_srcdir)/data/qmi-service-pbm.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-pbm.h && \
+		rm -f qmi-pbm.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-pbm.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-pbm
+
+# UIM service
+qmi-uim.h qmi-uim.c qmi-uim.sections: $(top_srcdir)/data/qmi-service-uim.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN)  \
+		rm -f qmi-uim.h && \
+		rm -f qmi-uim.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-uim.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-uim
+
+# OMA service
+qmi-oma.h qmi-oma.c qmi-oma.sections: $(top_srcdir)/data/qmi-service-oma.json $(top_srcdir)/build-aux/qmi-codegen/*.py $(top_srcdir)/build-aux/qmi-codegen/qmi-codegen
+	$(AM_V_GEN) \
+		rm -f qmi-oma.h && \
+		rm -f qmi-oma.c && \
+		$(top_srcdir)/build-aux/qmi-codegen/qmi-codegen \
+			--input $(top_srcdir)/data/qmi-service-oma.json \
+			--include $(top_srcdir)/data/qmi-common.json \
+			--output qmi-oma
+
+BUILT_SOURCES = $(GENERATED_H) $(GENERATED_C)
+
+nodist_libqmi_glib_generated_la_SOURCES = \
+	$(GENERATED_H) \
+	$(GENERATED_C)
+
+libqmi_glib_generated_la_CPPFLAGS = \
+	$(LIBQMI_GLIB_CFLAGS) \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/src/libqmi-glib \
+	-I$(top_builddir)/src/libqmi-glib \
+	-DLIBQMI_GLIB_COMPILATION \
+	-DG_LOG_DOMAIN=\"Qmi\" \
+	-Wno-unused-function
+
+libqmi_glib_generated_la_LIBADD = \
+	$(LIBQMI_GLIB_LIBS)
+
+includedir = @includedir@/libqmi-glib
+nodist_include_HEADERS = \
+	qmi-error-types.h \
+	qmi-enum-types.h \
+	qmi-flags64-types.h \
+	qmi-dms.h \
+	qmi-nas.h \
+	qmi-wds.h \
+	qmi-wms.h \
+	qmi-pds.h \
+	qmi-pbm.h \
+	qmi-uim.h \
+	qmi-oma.h
+
+CLEANFILES = $(GENERATED_H) $(GENERATED_C) $(GENERATED_SECTIONS)
diff --git a/src/libqmi-glib/libqmi-glib.h b/src/libqmi-glib/libqmi-glib.h
new file mode 100644
index 0000000..2143e86
--- /dev/null
+++ b/src/libqmi-glib/libqmi-glib.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ * Copyright (C) 2012 Google, Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_H_
+#define _LIBQMI_GLIB_H_
+
+#define __LIBQMI_GLIB_H_INSIDE__
+
+/* libqmi-glib headers */
+
+#include "qmi-version.h"
+#include "qmi-device.h"
+#include "qmi-client.h"
+#include "qmi-message.h"
+#include "qmi-enums.h"
+#include "qmi-utils.h"
+
+#include "qmi-enums-dms.h"
+#include "qmi-flags64-dms.h"
+#include "qmi-dms.h"
+
+#include "qmi-flags64-nas.h"
+#include "qmi-enums-nas.h"
+#include "qmi-nas.h"
+
+#include "qmi-enums-wds.h"
+#include "qmi-wds.h"
+
+#include "qmi-enums-wms.h"
+#include "qmi-wms.h"
+
+#include "qmi-enums-pds.h"
+#include "qmi-pds.h"
+
+#include "qmi-enums-pbm.h"
+#include "qmi-pbm.h"
+
+#include "qmi-enums-uim.h"
+#include "qmi-uim.h"
+
+#include "qmi-enums-oma.h"
+#include "qmi-oma.h"
+
+/* generated */
+#include "qmi-error-types.h"
+#include "qmi-enum-types.h"
+#include "qmi-flags64-types.h"
+
+#endif /* _LIBQMI_GLIB_H_ */
diff --git a/src/libqmi-glib/qmi-client.c b/src/libqmi-glib/qmi-client.c
new file mode 100644
index 0000000..aec7299
--- /dev/null
+++ b/src/libqmi-glib/qmi-client.c
@@ -0,0 +1,374 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#include <gio/gio.h>
+
+#include "qmi-error-types.h"
+#include "qmi-enum-types.h"
+#include "qmi-device.h"
+#include "qmi-client.h"
+#include "qmi-ctl.h"
+
+/**
+ * SECTION:qmi-client
+ * @title: QmiClient
+ * @short_description: Generic QMI client handling routines
+ *
+ * #QmiClient is a generic type representing a QMI client for any kind of
+ * #QmiService.
+ *
+ * These objects are created by a #QmiDevice with qmi_device_allocate_client(),
+ * and before completely disposing them qmi_device_release_client() needs to be
+ * called in order to release the unique client ID reserved.
+ */
+
+G_DEFINE_ABSTRACT_TYPE (QmiClient, qmi_client, G_TYPE_OBJECT);
+
+enum {
+    PROP_0,
+    PROP_DEVICE,
+    PROP_SERVICE,
+    PROP_CID,
+    PROP_VERSION_MAJOR,
+    PROP_VERSION_MINOR,
+    PROP_LAST
+};
+
+static GParamSpec *properties[PROP_LAST];
+
+struct _QmiClientPrivate {
+    QmiDevice *device;
+    QmiService service;
+    guint8 cid;
+    guint version_major;
+    guint version_minor;
+
+    guint16 transaction_id;
+};
+
+/*****************************************************************************/
+
+/**
+ * qmi_client_get_device:
+ * @self: a #QmiClient
+ *
+ * Get the #QmiDevice associated with this #QmiClient.
+ *
+ * Returns: a #GObject that must be freed with g_object_unref().
+ */
+GObject *
+qmi_client_get_device (QmiClient *self)
+{
+    GObject *device;
+
+    g_return_val_if_fail (QMI_IS_CLIENT (self), NULL);
+
+    g_object_get (G_OBJECT (self),
+                  QMI_CLIENT_DEVICE, &device,
+                  NULL);
+
+    return device;
+}
+
+/**
+ * qmi_client_peek_device:
+ * @self: a #QmiClient.
+ *
+ * Get the #QmiDevice associated with this #QmiClient, without increasing the reference count
+ * on the returned object.
+ *
+ * Returns: a #GObject. Do not free the returned object, it is owned by @self.
+ */
+GObject *
+qmi_client_peek_device (QmiClient *self)
+{
+    g_return_val_if_fail (QMI_IS_CLIENT (self), NULL);
+
+    return G_OBJECT (self->priv->device);
+}
+
+/**
+ * qmi_client_get_service:
+ * @self: A #QmiClient
+ *
+ * Get the service being used by this #QmiClient.
+ *
+ * Returns: a #QmiService.
+ */
+QmiService
+qmi_client_get_service (QmiClient *self)
+{
+    g_return_val_if_fail (QMI_IS_CLIENT (self), QMI_SERVICE_UNKNOWN);
+
+    return self->priv->service;
+}
+
+/**
+ * qmi_client_get_cid:
+ * @self: A #QmiClient
+ *
+ * Get the client ID of this #QmiClient.
+ *
+ * Returns: the client ID.
+ */
+guint8
+qmi_client_get_cid (QmiClient *self)
+{
+    g_return_val_if_fail (QMI_IS_CLIENT (self), QMI_CID_NONE);
+
+    return self->priv->cid;
+}
+
+/**
+ * qmi_client_get_version:
+ * @self: A #QmiClient
+ * @major: placeholder for the output major version.
+ * @minor: placeholder for the output minor version.
+ *
+ * Get the version of the service handled by this #QmiClient.
+ *
+ * Returns: %TRUE if the version was properly reported, %FALSE otherwise.
+ */
+gboolean
+qmi_client_get_version (QmiClient *self,
+                        guint *major,
+                        guint *minor)
+{
+    g_return_val_if_fail (QMI_IS_CLIENT (self), FALSE);
+
+    /* If the major version is greater than zero, assume it was
+     * set properly */
+    if (!self->priv->version_major)
+        return FALSE;
+
+    *major = self->priv->version_major;
+    *minor = self->priv->version_minor;
+    return TRUE;
+}
+
+/**
+ * qmi_client_check_version:
+ * @self: A #QmiClient
+ * @major: a major version.
+ * @minor: a minor version.
+ *
+ * Checks if the version of the service handled by this #QmiClient is greater
+ * or equal than the given version.
+ *
+ * Returns: %TRUE if the version of the service is greater or equal than the one given, %FALSE otherwise.
+ */
+gboolean
+qmi_client_check_version (QmiClient *self,
+                          guint major,
+                          guint minor)
+{
+    g_return_val_if_fail (QMI_IS_CLIENT (self), FALSE);
+
+    /* If the major version is greater than zero, assume it was
+     * set properly */
+    if (!self->priv->version_major)
+        return FALSE;
+
+    if (self->priv->version_major > major ||
+        (self->priv->version_major == major &&
+         self->priv->version_minor >= minor))
+        return TRUE;
+
+    return FALSE;
+}
+
+/**
+ * qmi_client_get_next_transaction_id:
+ * @self: A #QmiClient
+ *
+ * Acquire the next transaction ID of this #QmiClient.
+ * The internal transaction ID gets incremented.
+ *
+ * Returns: the next transaction ID.
+ */
+guint16
+qmi_client_get_next_transaction_id (QmiClient *self)
+{
+    guint16 next;
+
+    g_return_val_if_fail (QMI_IS_CLIENT (self), 0);
+
+    next = self->priv->transaction_id;
+
+    /* Don't go further than 8bits in the CTL service */
+    if ((self->priv->service == QMI_SERVICE_CTL &&
+         self->priv->transaction_id == G_MAXUINT8) ||
+        self->priv->transaction_id == G_MAXUINT16)
+        /* Reset! */
+        self->priv->transaction_id = 0x01;
+    else
+        self->priv->transaction_id++;
+
+    return next;
+}
+
+/*****************************************************************************/
+
+void
+qmi_client_process_indication (QmiClient *self,
+                               QmiMessage *message)
+{
+    if (QMI_CLIENT_GET_CLASS (self)->process_indication)
+        QMI_CLIENT_GET_CLASS (self)->process_indication (self, message);
+}
+
+/*****************************************************************************/
+
+static void
+set_property (GObject *object,
+              guint prop_id,
+              const GValue *value,
+              GParamSpec *pspec)
+{
+    QmiClient *self = QMI_CLIENT (object);
+
+    switch (prop_id) {
+    case PROP_DEVICE:
+        /* NOTE!! We do NOT keep a reference to the device here.
+         * Clients are OWNED by the device */
+        self->priv->device = g_value_get_object (value);
+        break;
+    case PROP_SERVICE:
+        self->priv->service = g_value_get_enum (value);
+        break;
+    case PROP_CID:
+        self->priv->cid = (guint8)g_value_get_uint (value);
+        break;
+    case PROP_VERSION_MAJOR:
+        self->priv->version_major = g_value_get_uint (value);
+        break;
+    case PROP_VERSION_MINOR:
+        self->priv->version_minor = g_value_get_uint (value);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+        break;
+    }
+}
+
+static void
+get_property (GObject *object,
+              guint prop_id,
+              GValue *value,
+              GParamSpec *pspec)
+{
+    QmiClient *self = QMI_CLIENT (object);
+
+    switch (prop_id) {
+    case PROP_DEVICE:
+        g_value_set_object (value, self->priv->device);
+        break;
+    case PROP_SERVICE:
+        g_value_set_enum (value, self->priv->service);
+        break;
+    case PROP_CID:
+        g_value_set_uint (value, (guint)self->priv->cid);
+        break;
+    case PROP_VERSION_MAJOR:
+        g_value_set_uint (value, self->priv->version_major);
+        break;
+    case PROP_VERSION_MINOR:
+        g_value_set_uint (value, self->priv->version_minor);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+        break;
+    }
+}
+
+static void
+qmi_client_init (QmiClient *self)
+{
+    self->priv = G_TYPE_INSTANCE_GET_PRIVATE ((self),
+                                              QMI_TYPE_CLIENT,
+                                              QmiClientPrivate);
+
+    /* Defaults */
+    self->priv->service = QMI_SERVICE_UNKNOWN;
+    self->priv->transaction_id = 0x01;
+    self->priv->cid = QMI_CID_NONE;
+    self->priv->version_major = 0;
+    self->priv->version_minor = 0;
+}
+
+static void
+qmi_client_class_init (QmiClientClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+    g_type_class_add_private (object_class, sizeof (QmiClientPrivate));
+
+    object_class->get_property = get_property;
+    object_class->set_property = set_property;
+
+    properties[PROP_DEVICE] =
+        g_param_spec_object (QMI_CLIENT_DEVICE,
+                             "Device",
+                             "The QMI device",
+                             QMI_TYPE_DEVICE,
+                             G_PARAM_READWRITE);
+    g_object_class_install_property (object_class, PROP_DEVICE, properties[PROP_DEVICE]);
+
+    properties[PROP_SERVICE] =
+        g_param_spec_enum (QMI_CLIENT_SERVICE,
+                           "Service",
+                           "QMI service this client is using",
+                           QMI_TYPE_SERVICE,
+                           QMI_SERVICE_UNKNOWN,
+                           G_PARAM_READWRITE);
+    g_object_class_install_property (object_class, PROP_SERVICE, properties[PROP_SERVICE]);
+
+    properties[PROP_CID] =
+        g_param_spec_uint (QMI_CLIENT_CID,
+                           "Client ID",
+                           "ID of the client registered into the QMI device",
+                           0,
+                           G_MAXUINT8,
+                           QMI_CID_NONE,
+                           G_PARAM_READWRITE);
+    g_object_class_install_property (object_class, PROP_CID, properties[PROP_CID]);
+
+    properties[PROP_VERSION_MAJOR] =
+        g_param_spec_uint (QMI_CLIENT_VERSION_MAJOR,
+                           "Version major",
+                           "Major version of the service handled by this client",
+                           0,
+                           G_MAXUINT,
+                           0,
+                           G_PARAM_READWRITE);
+    g_object_class_install_property (object_class, PROP_VERSION_MAJOR, properties[PROP_VERSION_MAJOR]);
+
+    properties[PROP_VERSION_MINOR] =
+        g_param_spec_uint (QMI_CLIENT_VERSION_MINOR,
+                           "Version minor",
+                           "Minor version of the service handled by this client",
+                           0,
+                           G_MAXUINT,
+                           0,
+                           G_PARAM_READWRITE);
+    g_object_class_install_property (object_class, PROP_VERSION_MINOR, properties[PROP_VERSION_MINOR]);
+}
diff --git a/src/libqmi-glib/qmi-client.h b/src/libqmi-glib/qmi-client.h
new file mode 100644
index 0000000..1305f15
--- /dev/null
+++ b/src/libqmi-glib/qmi-client.h
@@ -0,0 +1,99 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_CLIENT_H_
+#define _LIBQMI_GLIB_QMI_CLIENT_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+#include <glib-object.h>
+
+#include "qmi-enums.h"
+#include "qmi-message.h"
+
+G_BEGIN_DECLS
+
+#define QMI_CID_NONE      0x00
+#define QMI_CID_BROADCAST 0xFF
+
+#define QMI_TYPE_CLIENT            (qmi_client_get_type ())
+#define QMI_CLIENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), QMI_TYPE_CLIENT, QmiClient))
+#define QMI_CLIENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  QMI_TYPE_CLIENT, QmiClientClass))
+#define QMI_IS_CLIENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), QMI_TYPE_CLIENT))
+#define QMI_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  QMI_TYPE_CLIENT))
+#define QMI_CLIENT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  QMI_TYPE_CLIENT, QmiClientClass))
+
+typedef struct _QmiClient QmiClient;
+typedef struct _QmiClientClass QmiClientClass;
+typedef struct _QmiClientPrivate QmiClientPrivate;
+
+#define QMI_CLIENT_DEVICE        "client-device"
+#define QMI_CLIENT_SERVICE       "client-service"
+#define QMI_CLIENT_CID           "client-cid"
+#define QMI_CLIENT_VERSION_MAJOR "client-version-major"
+#define QMI_CLIENT_VERSION_MINOR "client-version-minor"
+
+/**
+ * QmiClient:
+ *
+ * The #QmiClient structure contains private data and should only be accessed
+ * using the provided API.
+ */
+struct _QmiClient {
+    /*< private >*/
+    GObject parent;
+    QmiClientPrivate *priv;
+};
+
+struct _QmiClientClass {
+    /*< private >*/
+    GObjectClass parent;
+
+    /* Virtual method to get indications processed */
+    void (* process_indication) (QmiClient *self,
+                                 QmiMessage *message);
+};
+
+GType qmi_client_get_type (void);
+
+GObject    *qmi_client_get_device  (QmiClient *self);
+GObject    *qmi_client_peek_device (QmiClient *self);
+QmiService  qmi_client_get_service (QmiClient *self);
+guint8      qmi_client_get_cid     (QmiClient *self);
+gboolean    qmi_client_get_version (QmiClient *self,
+                                    guint *major,
+                                    guint *minor);
+gboolean    qmi_client_check_version (QmiClient *self,
+                                      guint major,
+                                      guint minor);
+
+guint16     qmi_client_get_next_transaction_id (QmiClient *self);
+
+/* not part of the public API */
+void qmi_client_process_indication (QmiClient *self,
+                                    QmiMessage *message);
+
+G_END_DECLS
+
+#endif /* _LIBQMI_GLIB_QMI_CLIENT_H_ */
diff --git a/src/libqmi-glib/qmi-device.c b/src/libqmi-glib/qmi-device.c
new file mode 100644
index 0000000..2a04d4b
--- /dev/null
+++ b/src/libqmi-glib/qmi-device.c
@@ -0,0 +1,2331 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#include <errno.h>
+#include <string.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <unistd.h>
+#include <gio/gio.h>
+
+#include "qmi-device.h"
+#include "qmi-message.h"
+#include "qmi-ctl.h"
+#include "qmi-dms.h"
+#include "qmi-wds.h"
+#include "qmi-nas.h"
+#include "qmi-wms.h"
+#include "qmi-pds.h"
+#include "qmi-pbm.h"
+#include "qmi-uim.h"
+#include "qmi-oma.h"
+#include "qmi-utils.h"
+#include "qmi-error-types.h"
+#include "qmi-enum-types.h"
+
+/**
+ * SECTION:qmi-device
+ * @title: QmiDevice
+ * @short_description: Generic QMI device handling routines
+ *
+ * #QmiDevice is a generic type in charge of controlling the access of multiple
+ * #QmiClient objects to the managed QMI port.
+ *
+ * A #QmiDevice can only handle one single QMI port.
+ */
+
+static void async_initable_iface_init (GAsyncInitableIface *iface);
+
+G_DEFINE_TYPE_EXTENDED (QmiDevice, qmi_device, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, async_initable_iface_init))
+
+enum {
+    PROP_0,
+    PROP_FILE,
+    PROP_LAST
+};
+
+static GParamSpec *properties[PROP_LAST];
+
+struct _QmiDevicePrivate {
+    /* File */
+    GFile *file;
+    gchar *path;
+    gchar *path_display;
+
+    /* Implicit CTL client */
+    QmiClientCtl *client_ctl;
+    guint sync_indication_id;
+
+    /* Supported services */
+    GArray *supported_services;
+
+    /* I/O channel, set when the file is open */
+    GIOChannel *iochannel;
+    guint watch_id;
+    GByteArray *response;
+
+    /* HT to keep track of ongoing transactions */
+    GHashTable *transactions;
+
+    /* HT of clients that want to get indications */
+    GHashTable *registered_clients;
+};
+
+#define BUFFER_SIZE 2048
+
+/*****************************************************************************/
+/* Message transactions (private) */
+
+typedef struct {
+    QmiDevice *self;
+    gpointer key;
+} TransactionWaitContext;
+
+typedef struct {
+    QmiMessage *message;
+    GSimpleAsyncResult *result;
+    guint timeout_id;
+    GCancellable *cancellable;
+    gulong cancellable_id;
+    TransactionWaitContext *wait_ctx;
+} Transaction;
+
+static Transaction *
+transaction_new (QmiDevice *self,
+                 QmiMessage *message,
+                 GCancellable *cancellable,
+                 GAsyncReadyCallback callback,
+                 gpointer user_data)
+{
+    Transaction *tr;
+
+    tr = g_slice_new0 (Transaction);
+    tr->message = qmi_message_ref (message);
+    tr->result = g_simple_async_result_new (G_OBJECT (self),
+                                            callback,
+                                            user_data,
+                                            transaction_new);
+    if (cancellable)
+        tr->cancellable = g_object_ref (cancellable);
+
+    return tr;
+}
+
+static void
+transaction_complete_and_free (Transaction *tr,
+                               QmiMessage *reply,
+                               const GError *error)
+{
+    g_assert (reply != NULL || error != NULL);
+
+    if (tr->timeout_id)
+        g_source_remove (tr->timeout_id);
+
+    if (tr->cancellable) {
+        if (tr->cancellable_id)
+            g_cancellable_disconnect (tr->cancellable, tr->cancellable_id);
+        g_object_unref (tr->cancellable);
+    }
+
+    if (tr->wait_ctx)
+        g_slice_free (TransactionWaitContext, tr->wait_ctx);
+
+    if (reply)
+        g_simple_async_result_set_op_res_gpointer (tr->result,
+                                                   qmi_message_ref (reply),
+                                                   (GDestroyNotify)qmi_message_unref);
+    else
+        g_simple_async_result_set_from_error (tr->result, error);
+
+    g_simple_async_result_complete_in_idle (tr->result);
+    g_object_unref (tr->result);
+    qmi_message_unref (tr->message);
+    g_slice_free (Transaction, tr);
+}
+
+static inline gpointer
+build_transaction_key (QmiMessage *message)
+{
+    gpointer key;
+    guint8 service;
+    guint8 client_id;
+    guint16 transaction_id;
+
+    service = (guint8)qmi_message_get_service (message);
+    client_id = qmi_message_get_client_id (message);
+    transaction_id = qmi_message_get_transaction_id (message);
+
+    /* We're putting a 32 bit value into a gpointer */
+    key = GUINT_TO_POINTER ((((service << 8) | client_id) << 16) | transaction_id);
+
+    return key;
+}
+
+static Transaction *
+device_release_transaction (QmiDevice *self,
+                            gpointer key)
+{
+    Transaction *tr = NULL;
+
+    if (self->priv->transactions) {
+        tr = g_hash_table_lookup (self->priv->transactions, key);
+        if (tr)
+            /* If found, remove it from the HT */
+            g_hash_table_remove (self->priv->transactions, key);
+    }
+
+    return tr;
+}
+
+static gboolean
+transaction_timed_out (TransactionWaitContext *ctx)
+{
+    Transaction *tr;
+    GError *error = NULL;
+
+    tr = device_release_transaction (ctx->self, ctx->key);
+    tr->timeout_id = 0;
+
+    /* Complete transaction with a timeout error */
+    error = g_error_new (QMI_CORE_ERROR,
+                         QMI_CORE_ERROR_TIMEOUT,
+                         "Transaction timed out");
+    transaction_complete_and_free (tr, NULL, error);
+    g_error_free (error);
+
+    return FALSE;
+}
+
+static void
+transaction_cancelled (GCancellable *cancellable,
+                       TransactionWaitContext *ctx)
+{
+    Transaction *tr;
+    GError *error = NULL;
+
+    tr = device_release_transaction (ctx->self, ctx->key);
+    tr->cancellable_id = 0;
+
+    /* Complete transaction with an abort error */
+    error = g_error_new (QMI_PROTOCOL_ERROR,
+                         QMI_PROTOCOL_ERROR_ABORTED,
+                         "Transaction aborted");
+    transaction_complete_and_free (tr, NULL, error);
+    g_error_free (error);
+}
+
+static gboolean
+device_store_transaction (QmiDevice *self,
+                          Transaction *tr,
+                          guint timeout,
+                          GError **error)
+{
+    gpointer key;
+
+    if (G_UNLIKELY (!self->priv->transactions))
+        self->priv->transactions = g_hash_table_new (g_direct_hash,
+                                                     g_direct_equal);
+
+    key = build_transaction_key (tr->message);
+
+    /* Setup the timeout and cancellation */
+
+    tr->wait_ctx = g_slice_new (TransactionWaitContext);
+    tr->wait_ctx->self = self;
+    tr->wait_ctx->key = key; /* valid as long as the transaction is in the HT */
+
+    tr->timeout_id = g_timeout_add_seconds (timeout,
+                                            (GSourceFunc)transaction_timed_out,
+                                            tr->wait_ctx);
+
+    if (tr->cancellable) {
+        tr->cancellable_id = g_cancellable_connect (tr->cancellable,
+                                                    (GCallback)transaction_cancelled,
+                                                    tr->wait_ctx,
+                                                    NULL);
+        if (!tr->cancellable_id) {
+            g_set_error (error,
+                         QMI_PROTOCOL_ERROR,
+                         QMI_PROTOCOL_ERROR_ABORTED,
+                         "Request is already cancelled");
+            return FALSE;
+        }
+    }
+
+    /* Keep in the HT */
+    g_hash_table_insert (self->priv->transactions, key, tr);
+
+    return TRUE;
+}
+
+static Transaction *
+device_match_transaction (QmiDevice *self,
+                          QmiMessage *message)
+{
+    /* msg can be either the original message or the response */
+    return device_release_transaction (self, build_transaction_key (message));
+}
+
+/*****************************************************************************/
+/* Version info request */
+
+/**
+ * qmi_device_get_service_version_info_finish:
+ * @self: a #QmiDevice.
+ * @res: a #GAsyncResult.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with qmi_device_get_service_version_info().
+ *
+ * Returns: a #GArray of #QmiDeviceServiceVersionInfo elements, or #NULL if @error is set. The returned value should be freed with g_array_unref().
+ */
+GArray *
+qmi_device_get_service_version_info_finish (QmiDevice *self,
+                                            GAsyncResult *res,
+                                            GError **error)
+{
+    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
+        return NULL;
+
+    return g_array_ref (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res)));
+}
+
+static void
+version_info_ready (QmiClientCtl *client_ctl,
+                    GAsyncResult *res,
+                    GSimpleAsyncResult *simple)
+{
+    GArray *service_list = NULL;
+    GArray *out;
+    QmiMessageCtlGetVersionInfoOutput *output;
+    GError *error = NULL;
+    guint i;
+
+    /* Check result of the async operation */
+    output = qmi_client_ctl_get_version_info_finish (client_ctl, res, &error);
+    if (!output) {
+        g_simple_async_result_take_error (simple, error);
+        g_simple_async_result_complete (simple);
+        g_object_unref (simple);
+        return;
+    }
+
+    /* Check result of the QMI operation */
+    if (!qmi_message_ctl_get_version_info_output_get_result (output, &error)) {
+        qmi_message_ctl_get_version_info_output_unref (output);
+        g_simple_async_result_take_error (simple, error);
+        g_simple_async_result_complete (simple);
+        g_object_unref (simple);
+        return;
+    }
+
+    /* QMI operation succeeded, we can now get the outputs */
+    qmi_message_ctl_get_version_info_output_get_service_list (output, &service_list, NULL);
+    out = g_array_sized_new (FALSE, FALSE, sizeof (QmiDeviceServiceVersionInfo), service_list->len);
+    for (i = 0; i < service_list->len; i++) {
+        QmiMessageCtlGetVersionInfoOutputServiceListService *info;
+        QmiDeviceServiceVersionInfo outinfo;
+
+        info = &g_array_index (service_list,
+                               QmiMessageCtlGetVersionInfoOutputServiceListService,
+                               i);
+        outinfo.service = info->service;
+        outinfo.major_version = info->major_version;
+        outinfo.minor_version = info->minor_version;
+        g_array_append_val (out, outinfo);
+    }
+
+    qmi_message_ctl_get_version_info_output_unref (output);
+    g_simple_async_result_set_op_res_gpointer (simple, out, (GDestroyNotify)g_array_unref);
+    g_simple_async_result_complete (simple);
+    g_object_unref (simple);
+}
+
+/**
+ * qmi_device_get_service_version_info:
+ * @self: a #QmiDevice.
+ * @timeout: maximum time to wait for the method to complete, in seconds.
+ * @cancellable: a #GCancellable or %NULL.
+ * @callback: a #GAsyncReadyCallback to call when the request is satisfied.
+ * @user_data: user data to pass to @callback.
+ *
+ * Asynchronously requests the service version information of the device.
+ *
+ * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from.
+ *
+ * You can then call qmi_device_get_service_version_info_finish() to get the result of the operation.
+ */
+void
+qmi_device_get_service_version_info (QmiDevice *self,
+                                     guint timeout,
+                                     GCancellable *cancellable,
+                                     GAsyncReadyCallback callback,
+                                     gpointer user_data)
+{
+    qmi_client_ctl_get_version_info (
+        self->priv->client_ctl,
+        NULL,
+        timeout,
+        cancellable,
+        (GAsyncReadyCallback)version_info_ready,
+        g_simple_async_result_new (G_OBJECT (self),
+                                   callback,
+                                   user_data,
+                                   qmi_device_get_service_version_info));
+}
+
+/*****************************************************************************/
+/* Version info checks (private) */
+
+static const QmiMessageCtlGetVersionInfoOutputServiceListService *
+find_service_version_info (QmiDevice *self,
+                           QmiService service)
+{
+    guint i;
+
+    if (!self->priv->supported_services)
+        return NULL;
+
+    for (i = 0; i < self->priv->supported_services->len; i++) {
+        const QmiMessageCtlGetVersionInfoOutputServiceListService *info;
+
+        info = &g_array_index (self->priv->supported_services,
+                               QmiMessageCtlGetVersionInfoOutputServiceListService,
+                               i);
+
+        if (service == info->service)
+            return info;
+    }
+
+    return NULL;
+}
+
+static gboolean
+check_service_supported (QmiDevice *self,
+                         QmiService service)
+{
+    /* If we didn't check supported services, just assume it is supported */
+    if (!self->priv->supported_services) {
+        g_debug ("[%s] Assuming service '%s' is supported...",
+                 self->priv->path_display,
+                 qmi_service_get_string (service));
+        return TRUE;
+    }
+
+    return !!find_service_version_info (self, service);
+}
+
+static gboolean
+check_message_supported (QmiDevice *self,
+                         QmiMessage *message,
+                         GError **error)
+{
+    const QmiMessageCtlGetVersionInfoOutputServiceListService *info;
+    guint major = 0;
+    guint minor = 0;
+
+    /* If we didn't check supported services, just assume it is supported */
+    if (!self->priv->supported_services)
+        return TRUE;
+
+    /* For CTL, we assume all are supported */
+    if (qmi_message_get_service (message) == QMI_SERVICE_CTL)
+        return TRUE;
+
+    /* If we cannot get in which version this message was introduced, we'll just
+     * assume it's supported */
+    if (!qmi_message_get_version_introduced (message, &major, &minor))
+        return TRUE;
+
+    /* Get version info. It MUST exist because we allowed creating a client
+     * of this service type */
+    info = find_service_version_info (self, qmi_message_get_service (message));
+    g_assert (info != NULL);
+    g_assert (info->service == qmi_message_get_service (message));
+
+    /* If the version of the message is greater than the version of the service,
+     * report unsupported */
+    if (major > info->major_version ||
+        (major == info->major_version &&
+         minor > info->minor_version)) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_UNSUPPORTED,
+                     "QMI service '%s' version '%u.%u' required, got version '%u.%u'",
+                     qmi_service_get_string (qmi_message_get_service (message)),
+                     major, minor,
+                     info->major_version,
+                     info->minor_version);
+        return FALSE;
+    }
+
+    /* Supported! */
+    return TRUE;
+}
+
+/*****************************************************************************/
+
+/**
+ * qmi_device_get_file:
+ * @self: a #QmiDevice.
+ *
+ * Get the #GFile associated with this #QmiDevice.
+ *
+ * Returns: a #GFile that must be freed with g_object_unref().
+ */
+GFile *
+qmi_device_get_file (QmiDevice *self)
+{
+    GFile *file = NULL;
+
+    g_return_val_if_fail (QMI_IS_DEVICE (self), NULL);
+
+    g_object_get (G_OBJECT (self),
+                  QMI_DEVICE_FILE, &file,
+                  NULL);
+    return file;
+}
+
+/**
+ * qmi_device_peek_file:
+ * @self: a #QmiDevice.
+ *
+ * Get the #GFile associated with this #QmiDevice, without increasing the reference count
+ * on the returned object.
+ *
+ * Returns: a #GFile. Do not free the returned object, it is owned by @self.
+ */
+GFile *
+qmi_device_peek_file (QmiDevice *self)
+{
+    g_return_val_if_fail (QMI_IS_DEVICE (self), NULL);
+
+    return self->priv->file;
+}
+
+/**
+ * qmi_device_get_path:
+ * @self: a #QmiDevice.
+ *
+ * Get the system path of the underlying QMI device.
+ *
+ * Returns: the system path of the device.
+ */
+const gchar *
+qmi_device_get_path (QmiDevice *self)
+{
+    g_return_val_if_fail (QMI_IS_DEVICE (self), NULL);
+
+    return self->priv->path;
+}
+
+/**
+ * qmi_device_get_path_display:
+ * @self: a #QmiDevice.
+ *
+ * Get the system path of the underlying QMI device in UTF-8.
+ *
+ * Returns: UTF-8 encoded system path of the device.
+ */
+const gchar *
+qmi_device_get_path_display (QmiDevice *self)
+{
+    g_return_val_if_fail (QMI_IS_DEVICE (self), NULL);
+
+    return self->priv->path_display;
+}
+
+/**
+ * qmi_device_is_open:
+ * @self: a #QmiDevice.
+ *
+ * Checks whether the #QmiDevice is open for I/O.
+ *
+ * Returns: %TRUE if @self is open, %FALSE otherwise.
+ */
+gboolean
+qmi_device_is_open (QmiDevice *self)
+{
+    g_return_val_if_fail (QMI_IS_DEVICE (self), FALSE);
+
+    return !!self->priv->iochannel;
+}
+
+/*****************************************************************************/
+/* Register/Unregister clients that want to receive indications */
+
+static gpointer
+build_registered_client_key (guint8 cid,
+                             QmiService service)
+{
+    return GUINT_TO_POINTER (((guint8)service << 8) | cid);
+}
+
+static gboolean
+register_client (QmiDevice *self,
+                 QmiClient *client,
+                 GError **error)
+{
+    gpointer key;
+
+    key = build_registered_client_key (qmi_client_get_cid (client),
+                                       qmi_client_get_service (client));
+    /* Only add the new client if not already registered one with the same CID
+     * for the same service */
+    if (g_hash_table_lookup (self->priv->registered_clients, key)) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_FAILED,
+                     "A client with CID '%u' and service '%s' is already registered",
+                     qmi_client_get_cid (client),
+                     qmi_service_get_string (qmi_client_get_service (client)));
+        return FALSE;
+    }
+
+    g_hash_table_insert (self->priv->registered_clients,
+                         key,
+                         g_object_ref (client));
+    return TRUE;
+}
+
+static void
+unregister_client (QmiDevice *self,
+                   QmiClient *client)
+{
+    g_hash_table_remove (self->priv->registered_clients,
+                         build_registered_client_key (qmi_client_get_cid (client),
+                                                      qmi_client_get_service (client)));
+}
+
+/*****************************************************************************/
+/* Allocate new client */
+
+typedef struct {
+    QmiDevice *self;
+    GSimpleAsyncResult *result;
+    QmiService service;
+    GType client_type;
+    guint8 cid;
+} AllocateClientContext;
+
+static void
+allocate_client_context_complete_and_free (AllocateClientContext *ctx)
+{
+    g_simple_async_result_complete_in_idle (ctx->result);
+    g_object_unref (ctx->result);
+    g_object_unref (ctx->self);
+    g_slice_free (AllocateClientContext, ctx);
+}
+
+/**
+ * qmi_device_allocate_client_finish:
+ * @self: a #QmiDevice.
+ * @res: a #GAsyncResult.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with qmi_device_allocate_client().
+ *
+ * Returns: a newly allocated #QmiClient, or #NULL if @error is set.
+ */
+QmiClient *
+qmi_device_allocate_client_finish (QmiDevice *self,
+                                   GAsyncResult *res,
+                                   GError **error)
+{
+    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
+        return NULL;
+
+    return QMI_CLIENT (g_object_ref (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res))));
+}
+
+static void
+build_client_object (AllocateClientContext *ctx)
+{
+    gchar *version_string = NULL;
+    QmiClient *client;
+    GError *error = NULL;
+    const QmiMessageCtlGetVersionInfoOutputServiceListService *version_info;
+
+    /* We now have a proper CID for the client, we should be able to create it
+     * right away */
+    client = g_object_new (ctx->client_type,
+                           QMI_CLIENT_DEVICE,  ctx->self,
+                           QMI_CLIENT_SERVICE, ctx->service,
+                           QMI_CLIENT_CID,     ctx->cid,
+                           NULL);
+
+    /* Add version info to the client if it was retrieved */
+    version_info = find_service_version_info (ctx->self, ctx->service);
+    if (version_info)
+        g_object_set (client,
+                      QMI_CLIENT_VERSION_MAJOR, version_info->major_version,
+                      QMI_CLIENT_VERSION_MINOR, version_info->minor_version,
+                      NULL);
+
+    /* Register the client to get indications */
+    if (!register_client (ctx->self, client, &error)) {
+        g_prefix_error (&error,
+                        "Cannot register new client with CID '%u' and service '%s'",
+                        ctx->cid,
+                        qmi_service_get_string (ctx->service));
+        g_simple_async_result_take_error (ctx->result, error);
+        allocate_client_context_complete_and_free (ctx);
+        g_object_unref (client);
+        return;
+    }
+
+    /* Build version string for the logging */
+    if (ctx->self->priv->supported_services) {
+        const QmiMessageCtlGetVersionInfoOutputServiceListService *info;
+
+        info = find_service_version_info (ctx->self, ctx->service);
+        if (info)
+            version_string = g_strdup_printf ("%u.%u", info->major_version, info->minor_version);
+    }
+
+    g_debug ("[%s] Registered '%s' (version %s) client with ID '%u'",
+             ctx->self->priv->path_display,
+             qmi_service_get_string (ctx->service),
+             version_string ? version_string : "unknown",
+             ctx->cid);
+
+    g_free (version_string);
+
+    /* Client created and registered, complete successfully */
+    g_simple_async_result_set_op_res_gpointer (ctx->result,
+                                               client,
+                                               (GDestroyNotify)g_object_unref);
+    allocate_client_context_complete_and_free (ctx);
+}
+
+static void
+allocate_cid_ready (QmiClientCtl *client_ctl,
+                    GAsyncResult *res,
+                    AllocateClientContext *ctx)
+{
+    QmiMessageCtlAllocateCidOutput *output;
+    QmiService service;
+    guint8 cid;
+    GError *error = NULL;
+
+    /* Check result of the async operation */
+    output = qmi_client_ctl_allocate_cid_finish (client_ctl, res, &error);
+    if (!output) {
+        g_prefix_error (&error, "CID allocation failed in the CTL client: ");
+        g_simple_async_result_take_error (ctx->result, error);
+        allocate_client_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Check result of the QMI operation */
+    if (!qmi_message_ctl_allocate_cid_output_get_result (output, &error)) {
+        g_simple_async_result_take_error (ctx->result, error);
+        allocate_client_context_complete_and_free (ctx);
+        qmi_message_ctl_allocate_cid_output_unref (output);
+        return;
+    }
+
+    /* Allocation info is mandatory when result is success */
+    g_assert (qmi_message_ctl_allocate_cid_output_get_allocation_info (output, &service, &cid, NULL));
+
+    if (service != ctx->service) {
+        g_simple_async_result_set_error (
+            ctx->result,
+            QMI_CORE_ERROR,
+            QMI_CORE_ERROR_FAILED,
+            "CID allocation failed in the CTL client: "
+            "Service mismatch (requested '%s', got '%s')",
+            qmi_service_get_string (ctx->service),
+            qmi_service_get_string (service));
+        allocate_client_context_complete_and_free (ctx);
+        qmi_message_ctl_allocate_cid_output_unref (output);
+        return;
+    }
+
+    ctx->cid = cid;
+    build_client_object (ctx);
+    qmi_message_ctl_allocate_cid_output_unref (output);
+}
+
+/**
+ * qmi_device_allocate_client:
+ * @self: a #QmiDevice.
+ * @service: a valid #QmiService.
+ * @cid: a valid client ID, or #QMI_CID_NONE.
+ * @timeout: maximum time to wait.
+ * @cancellable: optional #GCancellable object, #NULL to ignore.
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished.
+ * @user_data: the data to pass to callback function.
+ *
+ * Asynchronously allocates a new #QmiClient in @self.
+ *
+ * If #QMI_CID_NONE is given in @cid, a new client ID will be allocated;
+ * otherwise a client with the given @cid will be generated.
+ *
+ * When the operation is finished @callback will be called. You can then call
+ * qmi_device_allocate_client_finish() to get the result of the operation.
+ *
+ * Note: Clients for the #QMI_SERVICE_CTL cannot be created with this method;
+ * instead get/peek the implicit one from @self.
+ */
+void
+qmi_device_allocate_client (QmiDevice *self,
+                            QmiService service,
+                            guint8 cid,
+                            guint timeout,
+                            GCancellable *cancellable,
+                            GAsyncReadyCallback callback,
+                            gpointer user_data)
+{
+    AllocateClientContext *ctx;
+
+    g_return_if_fail (QMI_IS_DEVICE (self));
+    g_return_if_fail (service != QMI_SERVICE_UNKNOWN);
+
+    ctx = g_slice_new0 (AllocateClientContext);
+    ctx->self = g_object_ref (self);
+    ctx->result = g_simple_async_result_new (G_OBJECT (self),
+                                             callback,
+                                             user_data,
+                                             qmi_device_allocate_client);
+    ctx->service = service;
+
+    /* Check if the requested service is supported by the device */
+    if (!check_service_supported (self, service)) {
+        g_simple_async_result_set_error (ctx->result,
+                                         QMI_CORE_ERROR,
+                                         QMI_CORE_ERROR_UNSUPPORTED,
+                                         "Service '%s' not supported by the device",
+                                         qmi_service_get_string (service));
+        allocate_client_context_complete_and_free (ctx);
+        return;
+    }
+
+    switch (service) {
+    case QMI_SERVICE_CTL:
+        g_simple_async_result_set_error (ctx->result,
+                                         QMI_CORE_ERROR,
+                                         QMI_CORE_ERROR_INVALID_ARGS,
+                                         "Cannot create additional clients for the CTL service");
+        allocate_client_context_complete_and_free (ctx);
+        return;
+
+    case QMI_SERVICE_DMS:
+        ctx->client_type = QMI_TYPE_CLIENT_DMS;
+        break;
+
+    case QMI_SERVICE_WDS:
+        ctx->client_type = QMI_TYPE_CLIENT_WDS;
+        break;
+
+    case QMI_SERVICE_NAS:
+        ctx->client_type = QMI_TYPE_CLIENT_NAS;
+        break;
+
+    case QMI_SERVICE_WMS:
+        ctx->client_type = QMI_TYPE_CLIENT_WMS;
+        break;
+
+    case QMI_SERVICE_PDS:
+        ctx->client_type = QMI_TYPE_CLIENT_PDS;
+        break;
+
+    case QMI_SERVICE_PBM:
+        ctx->client_type = QMI_TYPE_CLIENT_PBM;
+        break;
+
+    case QMI_SERVICE_UIM:
+        ctx->client_type = QMI_TYPE_CLIENT_UIM;
+        break;
+
+    case QMI_SERVICE_OMA:
+        ctx->client_type = QMI_TYPE_CLIENT_OMA;
+        break;
+
+    default:
+        g_simple_async_result_set_error (ctx->result,
+                                         QMI_CORE_ERROR,
+                                         QMI_CORE_ERROR_INVALID_ARGS,
+                                         "Clients for service '%s' not yet supported",
+                                         qmi_service_get_string (service));
+        allocate_client_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Allocate a new CID for the client to be created */
+    if (cid == QMI_CID_NONE) {
+        QmiMessageCtlAllocateCidInput *input;
+
+        input = qmi_message_ctl_allocate_cid_input_new ();
+        qmi_message_ctl_allocate_cid_input_set_service (input, ctx->service, NULL);
+
+        g_debug ("[%s] Allocating new client ID...",
+                 ctx->self->priv->path_display);
+        qmi_client_ctl_allocate_cid (self->priv->client_ctl,
+                                     input,
+                                     timeout,
+                                     cancellable,
+                                     (GAsyncReadyCallback)allocate_cid_ready,
+                                     ctx);
+
+        qmi_message_ctl_allocate_cid_input_unref (input);
+        return;
+    }
+
+    /* Reuse the given CID */
+    g_debug ("[%s] Reusing client CID '%u'...",
+             ctx->self->priv->path_display,
+             cid);
+    ctx->cid = cid;
+    build_client_object (ctx);
+}
+
+/*****************************************************************************/
+/* Release client */
+
+typedef struct {
+    QmiClient *client;
+    GSimpleAsyncResult *result;
+} ReleaseClientContext;
+
+static void
+release_client_context_complete_and_free (ReleaseClientContext *ctx)
+{
+    g_simple_async_result_complete_in_idle (ctx->result);
+    g_object_unref (ctx->result);
+    g_object_unref (ctx->client);
+    g_slice_free (ReleaseClientContext, ctx);
+}
+
+/**
+ * qmi_device_release_client_finish:
+ * @self: a #QmiDevice.
+ * @res: a #GAsyncResult.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with qmi_device_release_client().
+ *
+ * Note that even if the release operation returns an error, the client should
+ * anyway be considered released, and shouldn't be used afterwards.
+ *
+ * Returns: %TRUE if successful, or #NULL if @error is set.
+ */
+gboolean
+qmi_device_release_client_finish (QmiDevice *self,
+                                  GAsyncResult *res,
+                                  GError **error)
+{
+    return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
+}
+
+static void
+client_ctl_release_cid_ready (QmiClientCtl *client_ctl,
+                              GAsyncResult *res,
+                              ReleaseClientContext *ctx)
+{
+    GError *error = NULL;
+    QmiMessageCtlReleaseCidOutput *output;
+
+    /* Note: even if we return an error, the client is to be considered
+     * released! (so shouldn't be used) */
+
+    /* Check result of the async operation */
+    output = qmi_client_ctl_release_cid_finish (client_ctl, res, &error);
+    if (!output) {
+        g_simple_async_result_take_error (ctx->result, error);
+        release_client_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Check result of the QMI operation */
+    if (!qmi_message_ctl_release_cid_output_get_result (output, &error)) {
+        g_simple_async_result_take_error (ctx->result, error);
+        release_client_context_complete_and_free (ctx);
+        qmi_message_ctl_release_cid_output_unref (output);
+        return;
+    }
+
+    g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    release_client_context_complete_and_free (ctx);
+    qmi_message_ctl_release_cid_output_unref (output);
+}
+
+/**
+ * qmi_device_release_client:
+ * @self: a #QmiDevice.
+ * @client: the #QmiClient to release.
+ * @flags: mask of #QmiDeviceReleaseClientFlags specifying how the client should be released.
+ * @timeout: maximum time to wait.
+ * @cancellable: optional #GCancellable object, #NULL to ignore.
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished.
+ * @user_data: the data to pass to callback function.
+ *
+ * Asynchronously releases the #QmiClient from the #QmiDevice.
+ *
+ * Once the #QmiClient has been released, it cannot be used any more to
+ * perform operations.
+ *
+ *
+ * When the operation is finished @callback will be called. You can then call
+ * qmi_device_release_client_finish() to get the result of the operation.
+ */
+void
+qmi_device_release_client (QmiDevice *self,
+                           QmiClient *client,
+                           QmiDeviceReleaseClientFlags flags,
+                           guint timeout,
+                           GCancellable *cancellable,
+                           GAsyncReadyCallback callback,
+                           gpointer user_data)
+{
+    ReleaseClientContext *ctx;
+    QmiService service;
+    guint8 cid;
+
+    g_return_if_fail (QMI_IS_DEVICE (self));
+    g_return_if_fail (QMI_IS_CLIENT (client));
+
+    /* The CTL client should not have been created out of the QmiDevice */
+    g_assert (qmi_client_get_service (client) != QMI_SERVICE_CTL);
+
+    /* NOTE! The operation must not take a reference to self, or we won't be
+     * able to use it implicitly from our dispose() */
+
+    ctx = g_slice_new0 (ReleaseClientContext);
+    ctx->client = g_object_ref (client);
+    ctx->result = g_simple_async_result_new (G_OBJECT (self),
+                                             callback,
+                                             user_data,
+                                             qmi_device_release_client);
+
+    cid = qmi_client_get_cid (client);
+    service = (guint8)qmi_client_get_service (client);
+
+    /* Do not try to release an already released client */
+    if (cid == QMI_CID_NONE) {
+        g_simple_async_result_set_error (ctx->result,
+                                         QMI_CORE_ERROR,
+                                         QMI_CORE_ERROR_INVALID_ARGS,
+                                         "Client is already released");
+        release_client_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Unregister from device */
+    unregister_client (self, client);
+
+    g_debug ("[%s] Unregistered '%s' client with ID '%u'",
+             self->priv->path_display,
+             qmi_service_get_string (service),
+             cid);
+
+    /* Reset the contents of the client object, making it unusable */
+    g_object_set (client,
+                  QMI_CLIENT_CID,     QMI_CID_NONE,
+                  QMI_CLIENT_SERVICE, QMI_SERVICE_UNKNOWN,
+                  QMI_CLIENT_DEVICE,  NULL,
+                  NULL);
+
+    if (flags & QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID) {
+        QmiMessageCtlReleaseCidInput *input;
+
+        /* And now, really try to release the CID */
+        input = qmi_message_ctl_release_cid_input_new ();
+        qmi_message_ctl_release_cid_input_set_release_info (input, service,cid, NULL);
+
+        /* And now, really try to release the CID */
+        qmi_client_ctl_release_cid (self->priv->client_ctl,
+                                    input,
+                                    timeout,
+                                    cancellable,
+                                    (GAsyncReadyCallback)client_ctl_release_cid_ready,
+                                    ctx);
+
+        qmi_message_ctl_release_cid_input_unref (input);
+        return;
+    }
+
+    /* No need to release the CID, so just done */
+    g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    release_client_context_complete_and_free (ctx);
+    return;
+}
+
+/*****************************************************************************/
+/* Set instance ID */
+
+/**
+ * qmi_device_set_instance_id_finish:
+ * @self: a #QmiDevice.
+ * @res: a #GAsyncResult.
+ * @link_id: a placeholder for the output #guint16, or #NULL if not required.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with qmi_device_set_instance_id().
+ *
+ * Returns: %TRUE if successful, %FALSE if @error is set.
+ */
+gboolean
+qmi_device_set_instance_id_finish (QmiDevice *self,
+                                   GAsyncResult *res,
+                                   guint16 *link_id,
+                                   GError **error)
+{
+
+    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
+        return FALSE;
+
+    if (link_id)
+        *link_id = ((guint16) GPOINTER_TO_UINT (g_simple_async_result_get_op_res_gpointer (G_SIMPLE_ASYNC_RESULT (res))));
+    return TRUE;
+}
+
+static void
+set_instance_id_ready (QmiClientCtl *client_ctl,
+                       GAsyncResult *res,
+                       GSimpleAsyncResult *simple)
+{
+    QmiMessageCtlSetInstanceIdOutput *output;
+    GError *error = NULL;
+
+    /* Check result of the async operation */
+    output = qmi_client_ctl_set_instance_id_finish (client_ctl, res, &error);
+    if (!output)
+        g_simple_async_result_take_error (simple, error);
+    else {
+        /* Check result of the QMI operation */
+        if (!qmi_message_ctl_set_instance_id_output_get_result (output, &error))
+            g_simple_async_result_take_error (simple, error);
+        else {
+            guint16 link_id;
+
+            qmi_message_ctl_set_instance_id_output_get_link_id (output, &link_id, NULL);
+            g_simple_async_result_set_op_res_gpointer (simple, GUINT_TO_POINTER ((guint)link_id), NULL);
+        }
+        qmi_message_ctl_set_instance_id_output_unref (output);
+    }
+
+    g_simple_async_result_complete (simple);
+}
+
+/**
+ * qmi_device_set_instance_id:
+ * @self: a #QmiDevice.
+ * @instance_id: the instance ID.
+ * @timeout: maximum time to wait.
+ * @cancellable: optional #GCancellable object, #NULL to ignore.
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished.
+ * @user_data: the data to pass to callback function.
+ *
+ * Sets the instance ID of the #QmiDevice.
+ *
+ * When the operation is finished @callback will be called. You can then call
+ * qmi_device_set_instance_id_finish() to get the result of the operation.
+ */
+void
+qmi_device_set_instance_id (QmiDevice *self,
+                            guint8 instance_id,
+                            guint timeout,
+                            GCancellable *cancellable,
+                            GAsyncReadyCallback callback,
+                            gpointer user_data)
+{
+    GSimpleAsyncResult *result;
+    QmiMessageCtlSetInstanceIdInput *input;
+
+
+    result = g_simple_async_result_new (G_OBJECT (self),
+                                        callback,
+                                        user_data,
+                                        qmi_device_set_instance_id);
+
+    input = qmi_message_ctl_set_instance_id_input_new ();
+    qmi_message_ctl_set_instance_id_input_set_id (
+        input,
+        instance_id,
+        NULL);
+    qmi_client_ctl_set_instance_id (self->priv->client_ctl,
+                                    input,
+                                    timeout,
+                                    cancellable,
+                                    (GAsyncReadyCallback)set_instance_id_ready,
+                                    result);
+    qmi_message_ctl_set_instance_id_input_unref (input);
+}
+
+/*****************************************************************************/
+/* Open device */
+
+typedef struct {
+    QmiClient *client;
+    QmiMessage *message;
+} IdleIndicationContext;
+
+static gboolean
+process_indication_idle (IdleIndicationContext *ctx)
+{
+    g_assert (ctx->client != NULL);
+    g_assert (ctx->message != NULL);
+
+    qmi_client_process_indication (ctx->client, ctx->message);
+
+    g_object_unref (ctx->client);
+    qmi_message_unref (ctx->message);
+    g_slice_free (IdleIndicationContext, ctx);
+    return FALSE;
+}
+
+static void
+report_indication (QmiClient *client,
+                   QmiMessage *message)
+{
+    IdleIndicationContext *ctx;
+
+    /* Setup an idle to Pass the indication down to the client */
+    ctx = g_slice_new (IdleIndicationContext);
+    ctx->client = g_object_ref (client);
+    ctx->message = qmi_message_ref (message);
+    g_idle_add ((GSourceFunc)process_indication_idle, ctx);
+}
+
+static void
+process_message (QmiDevice *self,
+                 QmiMessage *message)
+{
+    if (qmi_utils_get_traces_enabled ()) {
+        gchar *printable;
+
+        printable = __qmi_utils_str_hex (((GByteArray *)message)->data,
+                                         ((GByteArray *)message)->len,
+                                         ':');
+        g_debug ("[%s] Received message...\n"
+                 ">>>>>> RAW:\n"
+                 ">>>>>>   length = %u\n"
+                 ">>>>>>   data   = %s\n",
+                 self->priv->path_display,
+                 ((GByteArray *)message)->len,
+                 printable);
+        g_free (printable);
+
+        printable = qmi_message_get_printable (message, ">>>>>> ");
+        g_debug ("[%s] Received message (translated)...\n%s",
+                 self->priv->path_display,
+                 printable);
+        g_free (printable);
+    }
+
+    if (qmi_message_is_indication (message)) {
+        if (qmi_message_get_client_id (message) == QMI_CID_BROADCAST) {
+            GHashTableIter iter;
+            gpointer key;
+            QmiClient *client;
+
+            g_hash_table_iter_init (&iter, self->priv->registered_clients);
+            while (g_hash_table_iter_next (&iter, &key, (gpointer *)&client)) {
+                /* For broadcast messages, report them just if the service matches */
+                if (qmi_message_get_service (message) == qmi_client_get_service (client))
+                    report_indication (client, message);
+            }
+        } else {
+            QmiClient *client;
+
+            client = g_hash_table_lookup (self->priv->registered_clients,
+                                          build_registered_client_key (qmi_message_get_client_id (message),
+                                                                       qmi_message_get_service (message)));
+            if (client)
+                report_indication (client, message);
+        }
+
+        return;
+    }
+
+    if (qmi_message_is_response (message)) {
+        Transaction *tr;
+
+        tr = device_match_transaction (self, message);
+        if (!tr)
+            g_debug ("[%s] No transaction matched in received message",
+                     self->priv->path_display);
+        else
+            /* Report the reply message */
+            transaction_complete_and_free (tr, message, NULL);
+
+        return;
+    }
+
+    g_debug ("[%s] Message received but it is neither an indication nor a response. Skipping it.",
+             self->priv->path_display);
+}
+
+static void
+parse_response (QmiDevice *self)
+{
+    do {
+        GError *error = NULL;
+        QmiMessage *message;
+
+        /* Every message received must start with the QMUX marker.
+         * If it doesn't, we broke framing :-/
+         * If we broke framing, an error should be reported and the device
+         * should get closed */
+        if (self->priv->response->len > 0 &&
+            self->priv->response->data[0] != QMI_MESSAGE_QMUX_MARKER) {
+            /* TODO: Report fatal error */
+            g_warning ("[%s] QMI framing error detected",
+                       self->priv->path_display);
+            return;
+        }
+
+        message = qmi_message_new_from_raw (self->priv->response, &error);
+        if (!message) {
+            if (!error)
+                /* More data we need */
+                return;
+
+            /* Warn about the issue */
+            g_warning ("[%s] Invalid QMI message received: '%s'",
+                       self->priv->path_display,
+                       error->message);
+            g_error_free (error);
+        } else {
+            /* Play with the received message */
+            process_message (self, message);
+            qmi_message_unref (message);
+        }
+    } while (self->priv->response->len > 0);
+}
+
+static gboolean
+data_available (GIOChannel *source,
+                GIOCondition condition,
+                QmiDevice *self)
+{
+    gsize bytes_read;
+    GIOStatus status;
+    gchar buffer[BUFFER_SIZE + 1];
+
+    if (condition & G_IO_HUP) {
+        g_debug ("[%s] unexpected port hangup!",
+                 self->priv->path_display);
+
+        if (self->priv->response &&
+            self->priv->response->len)
+            g_byte_array_remove_range (self->priv->response, 0, self->priv->response->len);
+
+        qmi_device_close (self, NULL);
+        return FALSE;
+    }
+
+    if (condition & G_IO_ERR) {
+        if (self->priv->response &&
+            self->priv->response->len)
+            g_byte_array_remove_range (self->priv->response, 0, self->priv->response->len);
+        return TRUE;
+    }
+
+    /* If not ready yet, prepare the response with default initial size. */
+    if (G_UNLIKELY (!self->priv->response))
+        self->priv->response = g_byte_array_sized_new (500);
+
+    do {
+        GError *error = NULL;
+
+        status = g_io_channel_read_chars (source,
+                                          buffer,
+                                          BUFFER_SIZE,
+                                          &bytes_read,
+                                          &error);
+        if (status == G_IO_STATUS_ERROR) {
+            if (error) {
+                g_warning ("[%s] error reading from the IOChannel: '%s'",
+                           self->priv->path_display,
+                           error->message);
+                g_error_free (error);
+            }
+
+            /* Port is closed; we're done */
+            if (self->priv->watch_id == 0)
+                break;
+        }
+
+        /* If no bytes read, just let g_io_channel wait for more data */
+        if (bytes_read == 0)
+            break;
+
+        if (bytes_read > 0)
+            g_byte_array_append (self->priv->response, (const guint8 *)buffer, bytes_read);
+
+        /* Try to parse what we already got */
+        parse_response (self);
+
+        /* And keep on if we were told to keep on */
+    } while (bytes_read == BUFFER_SIZE || status == G_IO_STATUS_AGAIN);
+
+    return TRUE;
+}
+
+static gboolean
+create_iochannel (QmiDevice *self,
+                  GError **error)
+{
+    GError *inner_error = NULL;
+    gint fd;
+
+    if (self->priv->iochannel) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_WRONG_STATE,
+                     "Already open");
+        return FALSE;
+    }
+
+    g_assert (self->priv->file);
+    g_assert (self->priv->path);
+
+    errno = 0;
+    fd = open (self->priv->path, O_RDWR | O_EXCL | O_NONBLOCK | O_NOCTTY);
+    if (fd < 0) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_FAILED,
+                     "Cannot open device file '%s': %s",
+                     self->priv->path_display,
+                     strerror (errno));
+        return FALSE;
+    }
+
+    /* Create new GIOChannel */
+    self->priv->iochannel = g_io_channel_unix_new (fd);
+
+    /* We don't want UTF-8 encoding, we're playing with raw binary data */
+    g_io_channel_set_encoding (self->priv->iochannel, NULL, NULL);
+
+    /* We don't want to get the channel buffered */
+    g_io_channel_set_buffered (self->priv->iochannel, FALSE);
+
+    /* Let the GIOChannel own the FD */
+    g_io_channel_set_close_on_unref (self->priv->iochannel, TRUE);
+
+    /* We don't want to get blocked while writing stuff */
+    if (!g_io_channel_set_flags (self->priv->iochannel,
+                                 G_IO_FLAG_NONBLOCK,
+                                 &inner_error)) {
+        g_prefix_error (&inner_error, "Cannot set non-blocking channel: ");
+        g_propagate_error (error, inner_error);
+        g_io_channel_shutdown (self->priv->iochannel, FALSE, NULL);
+        g_io_channel_unref (self->priv->iochannel);
+        self->priv->iochannel = NULL;
+        return FALSE;
+    }
+
+    self->priv->watch_id = g_io_add_watch (self->priv->iochannel,
+                                           G_IO_IN | G_IO_ERR | G_IO_HUP,
+                                           (GIOFunc)data_available,
+                                           self);
+
+    return !!self->priv->iochannel;
+}
+
+typedef struct {
+    QmiDevice *self;
+    GSimpleAsyncResult *result;
+    GCancellable *cancellable;
+    QmiDeviceOpenFlags flags;
+    guint timeout;
+    guint version_check_retries;
+} DeviceOpenContext;
+
+static void
+device_open_context_complete_and_free (DeviceOpenContext *ctx)
+{
+    g_simple_async_result_complete_in_idle (ctx->result);
+    g_object_unref (ctx->result);
+    if (ctx->cancellable)
+        g_object_unref (ctx->cancellable);
+    g_object_unref (ctx->self);
+    g_slice_free (DeviceOpenContext, ctx);
+}
+
+/**
+ * qmi_device_open_finish:
+ * @self: a #QmiDevice.
+ * @res: a #GAsyncResult.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an asynchronous open operation started with qmi_device_open().
+ *
+ * Returns: %TRUE if successful, %FALSE if @error is set.
+ */
+gboolean
+qmi_device_open_finish (QmiDevice *self,
+                        GAsyncResult *res,
+                        GError **error)
+{
+    return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
+}
+
+static void process_open_flags (DeviceOpenContext *ctx);
+
+static void
+ctl_set_data_format_ready (QmiClientCtl *client,
+                           GAsyncResult *res,
+                           DeviceOpenContext *ctx)
+{
+    QmiMessageCtlSetDataFormatOutput *output = NULL;
+    GError *error = NULL;
+
+    output = qmi_client_ctl_set_data_format_finish (client, res, &error);
+    /* Check result of the async operation */
+    if (!output) {
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Check result of the QMI operation */
+    if (!qmi_message_ctl_set_data_format_output_get_result (output, &error)) {
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        qmi_message_ctl_set_data_format_output_unref (output);
+        return;
+    }
+
+    g_debug ("[%s] Network port data format operation finished",
+             ctx->self->priv->path_display);
+
+    /* Keep on with next flags */
+    process_open_flags (ctx);
+    qmi_message_ctl_set_data_format_output_unref (output);
+}
+
+static void
+sync_ready (QmiClientCtl *client_ctl,
+            GAsyncResult *res,
+            DeviceOpenContext *ctx)
+{
+    GError *error = NULL;
+    QmiMessageCtlSyncOutput *output;
+
+    /* Check result of the async operation */
+    output = qmi_client_ctl_sync_finish (client_ctl, res, &error);
+    if(!output) {
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Check result of the QMI operation */
+    if (!qmi_message_ctl_sync_output_get_result (output, &error)) {
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        qmi_message_ctl_sync_output_unref (output);
+        return;
+    }
+
+    g_debug ("[%s] Sync operation finished",
+             ctx->self->priv->path_display);
+
+    /* Keep on with next flags */
+    process_open_flags (ctx);
+    qmi_message_ctl_sync_output_unref (output);
+}
+
+static void
+open_version_info_ready (QmiClientCtl *client_ctl,
+                         GAsyncResult *res,
+                         DeviceOpenContext *ctx)
+{
+    GArray *service_list;
+    QmiMessageCtlGetVersionInfoOutput *output;
+    GError *error = NULL;
+    guint i;
+
+    /* Check result of the async operation */
+    output = qmi_client_ctl_get_version_info_finish (client_ctl, res, &error);
+    if (!output) {
+        if (g_error_matches (error, QMI_CORE_ERROR, QMI_CORE_ERROR_TIMEOUT)) {
+            /* Update retries... */
+            ctx->version_check_retries--;
+            /* If retries left, retry */
+            if (ctx->version_check_retries > 0) {
+                g_error_free (error);
+                qmi_client_ctl_get_version_info (ctx->self->priv->client_ctl,
+                                                 NULL,
+                                                 1,
+                                                 ctx->cancellable,
+                                                 (GAsyncReadyCallback)open_version_info_ready,
+                                                 ctx);
+                return;
+            }
+
+            /* Otherwise, propagate the error */
+        }
+
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Check result of the QMI operation */
+    if (!qmi_message_ctl_get_version_info_output_get_result (output, &error)) {
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        qmi_message_ctl_get_version_info_output_unref (output);
+        return;
+    }
+
+    /* QMI operation succeeded, we can now get the outputs */
+    service_list = NULL;
+    qmi_message_ctl_get_version_info_output_get_service_list (output,
+                                                              &service_list,
+                                                              NULL);
+    ctx->self->priv->supported_services = g_array_ref (service_list);
+
+    g_debug ("[%s] QMI Device supports %u services:",
+             ctx->self->priv->path_display,
+             ctx->self->priv->supported_services->len);
+    for (i = 0; i < ctx->self->priv->supported_services->len; i++) {
+        QmiMessageCtlGetVersionInfoOutputServiceListService *info;
+        const gchar *service_str;
+
+        info = &g_array_index (ctx->self->priv->supported_services,
+                               QmiMessageCtlGetVersionInfoOutputServiceListService,
+                               i);
+        service_str = qmi_service_get_string (info->service);
+        if (service_str)
+            g_debug ("[%s]    %s (%u.%u)",
+                     ctx->self->priv->path_display,
+                     service_str,
+                     info->major_version,
+                     info->minor_version);
+        else
+            g_debug ("[%s]    unknown [0x%02x] (%u.%u)",
+                     ctx->self->priv->path_display,
+                     info->service,
+                     info->major_version,
+                     info->minor_version);
+    }
+
+    /* Keep on with next flags */
+    process_open_flags (ctx);
+    qmi_message_ctl_get_version_info_output_unref (output);
+}
+
+#define NETPORT_FLAGS (QMI_DEVICE_OPEN_FLAGS_NET_802_3 | \
+                       QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP | \
+                       QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER | \
+                       QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER)
+
+static void
+process_open_flags (DeviceOpenContext *ctx)
+{
+    /* Query version info? */
+    if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_VERSION_INFO) {
+        ctx->flags &= ~QMI_DEVICE_OPEN_FLAGS_VERSION_INFO;
+        /* Setup how many times to retry... We'll retry once per second */
+        ctx->version_check_retries = ctx->timeout > 0 ? ctx->timeout : 1;
+        g_debug ("[%s] Checking version info (%u retries)...",
+                 ctx->self->priv->path_display,
+                 ctx->version_check_retries);
+        qmi_client_ctl_get_version_info (ctx->self->priv->client_ctl,
+                                         NULL,
+                                         1,
+                                         ctx->cancellable,
+                                         (GAsyncReadyCallback)open_version_info_ready,
+                                         ctx);
+        return;
+    }
+
+    /* Sync? */
+    if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_SYNC) {
+        g_debug ("[%s] Running sync...",
+                 ctx->self->priv->path_display);
+        ctx->flags &= ~QMI_DEVICE_OPEN_FLAGS_SYNC;
+        qmi_client_ctl_sync (ctx->self->priv->client_ctl,
+                             NULL,
+                             ctx->timeout,
+                             ctx->cancellable,
+                             (GAsyncReadyCallback)sync_ready,
+                             ctx);
+        return;
+    }
+
+    /* Network port setup */
+    if (ctx->flags & NETPORT_FLAGS) {
+        QmiMessageCtlSetDataFormatInput *input;
+        QmiCtlDataFormat qos = QMI_CTL_DATA_FORMAT_QOS_FLOW_HEADER_ABSENT;
+        QmiCtlDataLinkProtocol link_protocol = QMI_CTL_DATA_LINK_PROTOCOL_802_3;
+
+        g_debug ("[%s] Setting network port data format...",
+                 ctx->self->priv->path_display);
+
+        input = qmi_message_ctl_set_data_format_input_new ();
+
+        if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER)
+            qos = QMI_CTL_DATA_FORMAT_QOS_FLOW_HEADER_PRESENT;
+        qmi_message_ctl_set_data_format_input_set_format (input, qos, NULL);
+
+        if (ctx->flags & QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP)
+            link_protocol = QMI_CTL_DATA_LINK_PROTOCOL_RAW_IP;
+        qmi_message_ctl_set_data_format_input_set_protocol (input, link_protocol, NULL);
+
+        ctx->flags &= ~NETPORT_FLAGS;
+        qmi_client_ctl_set_data_format (ctx->self->priv->client_ctl,
+                                        input,
+                                        5,
+                                        NULL,
+                                        (GAsyncReadyCallback)ctl_set_data_format_ready,
+                                        ctx);
+        qmi_message_ctl_set_data_format_input_unref (input);
+        return;
+    }
+
+    /* No more flags to process, done we are */
+    g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    device_open_context_complete_and_free (ctx);
+}
+
+/**
+ * qmi_device_open:
+ * @self: a #QmiDevice.
+ * @flags: mask of #QmiDeviceOpenFlags specifying how the device should be opened.
+ * @timeout: maximum time, in seconds, to wait for the device to be opened.
+ * @cancellable: optional #GCancellable object, #NULL to ignore.
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished.
+ * @user_data: the data to pass to callback function.
+ *
+ * Asynchronously opens a #QmiDevice for I/O.
+ *
+ * When the operation is finished @callback will be called. You can then call
+ * qmi_device_open_finish() to get the result of the operation.
+ */
+void
+qmi_device_open (QmiDevice *self,
+                 QmiDeviceOpenFlags flags,
+                 guint timeout,
+                 GCancellable *cancellable,
+                 GAsyncReadyCallback callback,
+                 gpointer user_data)
+{
+    DeviceOpenContext *ctx;
+    GError *error = NULL;
+
+    /* Raw IP and 802.3 are mutually exclusive */
+    g_return_if_fail (!((flags & QMI_DEVICE_OPEN_FLAGS_NET_802_3) &&
+                        (flags & QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP)));
+    /* QoS and no QoS are mutually exclusive */
+    g_return_if_fail (!((flags & QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER) &&
+                        (flags & QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER)));
+    /* At least one of both link protocol and QoS must be specified */
+    if (flags & (QMI_DEVICE_OPEN_FLAGS_NET_802_3 | QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP))
+        g_return_if_fail (flags & (QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER | QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER));
+    if (flags & (QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER | QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER))
+        g_return_if_fail (flags & (QMI_DEVICE_OPEN_FLAGS_NET_802_3 | QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP));
+
+    g_return_if_fail (QMI_IS_DEVICE (self));
+
+    ctx = g_slice_new (DeviceOpenContext);
+    ctx->self = g_object_ref (self);
+    ctx->result = g_simple_async_result_new (G_OBJECT (self),
+                                             callback,
+                                             user_data,
+                                             qmi_device_open);
+    ctx->flags = flags;
+    ctx->timeout = timeout;
+    ctx->cancellable = (cancellable ? g_object_ref (cancellable) : NULL);
+
+    if (!create_iochannel (self, &error)) {
+        g_prefix_error (&error,
+                        "Cannot open QMI device: ");
+        g_simple_async_result_take_error (ctx->result, error);
+        device_open_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Process all open flags */
+    process_open_flags (ctx);
+}
+
+/*****************************************************************************/
+/* Close channel */
+
+static gboolean
+destroy_iochannel (QmiDevice *self,
+                   GError **error)
+{
+    GError *inner_error = NULL;
+
+    /* Already closed? */
+    if (!self->priv->iochannel)
+        return TRUE;
+
+    g_io_channel_shutdown (self->priv->iochannel, TRUE, &inner_error);
+
+    /* Failures when closing still make the device to get closed */
+    g_io_channel_unref (self->priv->iochannel);
+    self->priv->iochannel = NULL;
+
+    if (self->priv->watch_id) {
+        g_source_remove (self->priv->watch_id);
+        self->priv->watch_id = 0;
+    }
+
+    if (self->priv->response) {
+        g_byte_array_unref (self->priv->response);
+        self->priv->response = NULL;
+    }
+
+    if (inner_error) {
+        g_propagate_error (error, inner_error);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/**
+ * qmi_device_close:
+ * @self: a #QmiDevice
+ * @error: Return location for error or %NULL.
+ *
+ * Synchronously closes a #QmiDevice, preventing any further I/O.
+ *
+ * Closing a #QmiDevice multiple times will not return an error.
+ *
+ * Returns: %TRUE if successful, %FALSE if @error is set.
+ */
+gboolean
+qmi_device_close (QmiDevice *self,
+                  GError **error)
+{
+    g_return_val_if_fail (QMI_IS_DEVICE (self), FALSE);
+
+    if (!destroy_iochannel (self, error)) {
+        g_prefix_error (error,
+                        "Cannot close QMI device: ");
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/*****************************************************************************/
+/* Command */
+
+/**
+ * qmi_device_command_finish:
+ * @self: a #QmiDevice.
+ * @res: a #GAsyncResult.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with qmi_device_command().
+ *
+ * Returns: a #QmiMessage response, or #NULL if @error is set. The returned value should be freed with qmi_message_unref().
+ */
+QmiMessage *
+qmi_device_command_finish (QmiDevice *self,
+                           GAsyncResult *res,
+                           GError **error)
+{
+    if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
+        return NULL;
+
+    return qmi_message_ref (g_simple_async_result_get_op_res_gpointer (
+                                G_SIMPLE_ASYNC_RESULT (res)));
+}
+
+/**
+ * qmi_device_command:
+ * @self: a #QmiDevice.
+ * @message: the message to send.
+ * @timeout: maximum time, in seconds, to wait for the response.
+ * @cancellable: a #GCancellable, or %NULL.
+ * @callback: a #GAsyncReadyCallback to call when the operation is finished.
+ * @user_data: the data to pass to callback function.
+ *
+ * Asynchronously sends a #QmiMessage to the device.
+ *
+ * When the operation is finished @callback will be called. You can then call
+ * qmi_device_command_finish() to get the result of the operation.
+ */
+void
+qmi_device_command (QmiDevice *self,
+                    QmiMessage *message,
+                    guint timeout,
+                    GCancellable *cancellable,
+                    GAsyncReadyCallback callback,
+                    gpointer user_data)
+{
+    GError *error = NULL;
+    Transaction *tr;
+    gconstpointer raw_message;
+    gsize raw_message_len;
+    gsize written;
+    GIOStatus write_status;
+
+    g_return_if_fail (QMI_IS_DEVICE (self));
+    g_return_if_fail (message != NULL);
+
+    tr = transaction_new (self, message, cancellable, callback, user_data);
+
+    /* Device must be open */
+    if (!self->priv->iochannel) {
+        error = g_error_new (QMI_CORE_ERROR,
+                             QMI_CORE_ERROR_WRONG_STATE,
+                             "Device must be open to send commands");
+        transaction_complete_and_free (tr, NULL, error);
+        g_error_free (error);
+        return;
+    }
+
+    /* Non-CTL services should use a proper CID */
+    if (qmi_message_get_service (message) != QMI_SERVICE_CTL &&
+        qmi_message_get_client_id (message) == 0) {
+        error = g_error_new (QMI_CORE_ERROR,
+                             QMI_CORE_ERROR_FAILED,
+                             "Cannot send message in service '%s' without a CID",
+                             qmi_service_get_string (qmi_message_get_service (message)));
+        transaction_complete_and_free (tr, NULL, error);
+        g_error_free (error);
+        return;
+    }
+
+    /* Check if the message to be sent is supported by the device
+     * (only applicable if we did version info check when opening) */
+    if (!check_message_supported (self, message, &error)) {
+        g_prefix_error (&error, "Cannot send message: ");
+        transaction_complete_and_free (tr, NULL, error);
+        g_error_free (error);
+        return;
+    }
+
+    /* Get raw message */
+    raw_message = qmi_message_get_raw (message, &raw_message_len, &error);
+    if (!raw_message) {
+        g_prefix_error (&error, "Cannot get raw message: ");
+        transaction_complete_and_free (tr, NULL, error);
+        g_error_free (error);
+        return;
+    }
+
+    /* Setup context to match response */
+    if (!device_store_transaction (self, tr, timeout, &error)) {
+        g_prefix_error (&error, "Cannot store transaction: ");
+        transaction_complete_and_free (tr, NULL, error);
+        g_error_free (error);
+        return;
+    }
+
+    if (qmi_utils_get_traces_enabled ()) {
+        gchar *printable;
+
+        printable = __qmi_utils_str_hex (((GByteArray *)message)->data,
+                                         ((GByteArray *)message)->len,
+                                         ':');
+        g_debug ("[%s] Sent message...\n"
+                 "<<<<<< RAW:\n"
+                 "<<<<<<   length = %u\n"
+                 "<<<<<<   data   = %s\n",
+                 self->priv->path_display,
+                 ((GByteArray *)message)->len,
+                 printable);
+        g_free (printable);
+
+        printable = qmi_message_get_printable (message, "<<<<<< ");
+        g_debug ("[%s] Sent message (translated)...\n%s",
+                 self->priv->path_display,
+                 printable);
+        g_free (printable);
+    }
+
+    written = 0;
+    write_status = G_IO_STATUS_AGAIN;
+    while (write_status == G_IO_STATUS_AGAIN) {
+        write_status = g_io_channel_write_chars (self->priv->iochannel,
+                                                 raw_message,
+                                                 (gssize)raw_message_len,
+                                                 &written,
+                                                 &error);
+        switch (write_status) {
+        case G_IO_STATUS_ERROR:
+            g_prefix_error (&error, "Cannot write message: ");
+
+            /* Match transaction so that we remove it from our tracking table */
+            tr = device_match_transaction (self, message);
+            transaction_complete_and_free (tr, NULL, error);
+            g_error_free (error);
+            return;
+
+        case G_IO_STATUS_EOF:
+            /* We shouldn't get EOF when writing */
+            g_assert_not_reached ();
+            break;
+
+        case G_IO_STATUS_NORMAL:
+            /* All good, we'll exit the loop now */
+            break;
+
+        case G_IO_STATUS_AGAIN:
+            /* We're in a non-blocking channel and therefore we're up to receive
+             * EAGAIN; just retry in this case. TODO: in an idle? */
+            break;
+        }
+    }
+
+    /* Just return, we'll get response asynchronously */
+}
+
+/*****************************************************************************/
+/* New QMI device */
+
+/**
+ * qmi_device_new_finish:
+ * @res: a #GAsyncResult.
+ * @error: Return location for error or %NULL.
+ *
+ * Finishes an operation started with qmi_device_new().
+ *
+ * Returns: A newly created #QmiDevice, or #NULL if @error is set.
+ */
+QmiDevice *
+qmi_device_new_finish (GAsyncResult *res,
+                       GError **error)
+{
+  GObject *ret;
+  GObject *source_object;
+
+  source_object = g_async_result_get_source_object (res);
+  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
+  g_object_unref (source_object);
+
+  return (ret ? QMI_DEVICE (ret) : NULL);
+}
+
+/**
+ * qmi_device_new:
+ * @file: a #GFile.
+ * @cancellable: optional #GCancellable object, #NULL to ignore.
+ * @callback: a #GAsyncReadyCallback to call when the initialization is finished.
+ * @user_data: the data to pass to callback function.
+ *
+ * Asynchronously creates a #QmiDevice object to manage @file.
+ * When the operation is finished, @callback will be invoked. You can then call
+ * qmi_device_new_finish() to get the result of the operation.
+ */
+void
+qmi_device_new (GFile *file,
+                GCancellable *cancellable,
+                GAsyncReadyCallback callback,
+                gpointer user_data)
+{
+    g_async_initable_new_async (QMI_TYPE_DEVICE,
+                                G_PRIORITY_DEFAULT,
+                                cancellable,
+                                callback,
+                                user_data,
+                                QMI_DEVICE_FILE, file,
+                                NULL);
+}
+
+/*****************************************************************************/
+/* Async init */
+
+typedef struct {
+    QmiDevice *self;
+    GSimpleAsyncResult *result;
+    GCancellable *cancellable;
+} InitContext;
+
+static void
+init_context_complete_and_free (InitContext *ctx)
+{
+    g_simple_async_result_complete_in_idle (ctx->result);
+    if (ctx->cancellable)
+        g_object_unref (ctx->cancellable);
+    g_object_unref (ctx->result);
+    g_object_unref (ctx->self);
+    g_slice_free (InitContext, ctx);
+}
+
+static gboolean
+initable_init_finish (GAsyncInitable  *initable,
+                      GAsyncResult    *result,
+                      GError         **error)
+{
+    return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error);
+}
+
+static void
+sync_indication_cb (QmiClientCtl *client_ctl,
+                    QmiDevice *self)
+{
+    /* Just log about it */
+    g_debug ("[%s] Sync indication received",
+             self->priv->path_display);
+}
+
+static void
+query_info_async_ready (GFile *file,
+                        GAsyncResult *res,
+                        InitContext *ctx)
+{
+    GError *error = NULL;
+    GFileInfo *info;
+
+    info = g_file_query_info_finish (file, res, &error);
+    if (!info) {
+        g_prefix_error (&error,
+                        "Couldn't query file info: ");
+        g_simple_async_result_take_error (ctx->result, error);
+        init_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Our QMI device must be of SPECIAL type */
+    if (g_file_info_get_file_type (info) != G_FILE_TYPE_SPECIAL) {
+        g_simple_async_result_set_error (ctx->result,
+                                         QMI_CORE_ERROR,
+                                         QMI_CORE_ERROR_FAILED,
+                                         "Wrong file type");
+        init_context_complete_and_free (ctx);
+        return;
+    }
+    g_object_unref (info);
+
+    /* Create the implicit CTL client */
+    ctx->self->priv->client_ctl = g_object_new (QMI_TYPE_CLIENT_CTL,
+                                                QMI_CLIENT_DEVICE,  ctx->self,
+                                                QMI_CLIENT_SERVICE, QMI_SERVICE_CTL,
+                                                QMI_CLIENT_CID,     QMI_CID_NONE,
+                                                NULL);
+
+    /* Register the CTL client to get indications */
+    register_client (ctx->self,
+                     QMI_CLIENT (ctx->self->priv->client_ctl),
+                     &error);
+    g_assert_no_error (error);
+
+    /* Connect to 'Sync' indications */
+    ctx->self->priv->sync_indication_id =
+        g_signal_connect (ctx->self->priv->client_ctl,
+                          "sync",
+                          G_CALLBACK (sync_indication_cb),
+                          ctx->self);
+
+    /* Done we are */
+    g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    init_context_complete_and_free (ctx);
+}
+
+static void
+initable_init_async (GAsyncInitable *initable,
+                     int io_priority,
+                     GCancellable *cancellable,
+                     GAsyncReadyCallback callback,
+                     gpointer user_data)
+{
+    InitContext *ctx;
+
+    ctx = g_slice_new0 (InitContext);
+    ctx->self = g_object_ref (initable);
+    if (cancellable)
+        ctx->cancellable = g_object_ref (cancellable);
+    ctx->result = g_simple_async_result_new (G_OBJECT (initable),
+                                             callback,
+                                             user_data,
+                                             initable_init_async);
+
+    /* We need a proper file to initialize */
+    if (!ctx->self->priv->file) {
+        g_simple_async_result_set_error (ctx->result,
+                                         QMI_CORE_ERROR,
+                                         QMI_CORE_ERROR_INVALID_ARGS,
+                                         "Cannot initialize QMI device: No file given");
+        init_context_complete_and_free (ctx);
+        return;
+    }
+
+    /* Check the file type. Note that this is just a quick check to avoid
+     * creating QmiDevices pointing to a location already known not to be a QMI
+     * device. */
+    g_file_query_info_async (ctx->self->priv->file,
+                             G_FILE_ATTRIBUTE_STANDARD_TYPE,
+                             G_FILE_QUERY_INFO_NONE,
+                             G_PRIORITY_DEFAULT,
+                             ctx->cancellable,
+                             (GAsyncReadyCallback)query_info_async_ready,
+                             ctx);
+}
+
+/*****************************************************************************/
+
+static void
+set_property (GObject *object,
+              guint prop_id,
+              const GValue *value,
+              GParamSpec *pspec)
+{
+    QmiDevice *self = QMI_DEVICE (object);
+
+    switch (prop_id) {
+    case PROP_FILE:
+        g_assert (self->priv->file == NULL);
+        self->priv->file = g_value_dup_object (value);
+        self->priv->path = g_file_get_path (self->priv->file);
+        self->priv->path_display = g_filename_display_name (self->priv->path);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+        break;
+    }
+}
+
+static void
+get_property (GObject *object,
+              guint prop_id,
+              GValue *value,
+              GParamSpec *pspec)
+{
+    QmiDevice *self = QMI_DEVICE (object);
+
+    switch (prop_id) {
+    case PROP_FILE:
+        g_value_set_object (value, self->priv->file);
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+        break;
+    }
+}
+
+static void
+qmi_device_init (QmiDevice *self)
+{
+    self->priv = G_TYPE_INSTANCE_GET_PRIVATE ((self),
+                                              QMI_TYPE_DEVICE,
+                                              QmiDevicePrivate);
+
+    self->priv->registered_clients = g_hash_table_new_full (g_direct_hash,
+                                                            g_direct_equal,
+                                                            NULL,
+                                                            g_object_unref);
+}
+
+static gboolean
+foreach_warning (gpointer key,
+                 QmiClient *client,
+                 QmiDevice *self)
+{
+    g_warning ("[%s] QMI client for service '%s' with CID '%u' wasn't released",
+               self->priv->path_display,
+               qmi_service_get_string (qmi_client_get_service (client)),
+               qmi_client_get_cid (client));
+
+    return TRUE;
+}
+
+static void
+dispose (GObject *object)
+{
+    QmiDevice *self = QMI_DEVICE (object);
+
+    g_clear_object (&self->priv->file);
+
+    /* unregister our CTL client */
+    if (self->priv->client_ctl)
+        unregister_client (self, QMI_CLIENT (self->priv->client_ctl));
+
+    /* If clients were left unreleased, we'll just warn about it.
+     * There is no point in trying to request CID releases, as the device
+     * itself is being disposed. */
+    g_hash_table_foreach_remove (self->priv->registered_clients,
+                                 (GHRFunc)foreach_warning,
+                                 self);
+
+    if (self->priv->sync_indication_id &&
+        self->priv->client_ctl) {
+        g_signal_handler_disconnect (self->priv->client_ctl,
+                                     self->priv->sync_indication_id);
+        self->priv->sync_indication_id = 0;
+    }
+    g_clear_object (&self->priv->client_ctl);
+
+    G_OBJECT_CLASS (qmi_device_parent_class)->dispose (object);
+}
+
+static void
+finalize (GObject *object)
+{
+    QmiDevice *self = QMI_DEVICE (object);
+
+    /* Transactions keep refs to the device, so it's actually
+     * impossible to have any content in the HT */
+    if (self->priv->transactions) {
+        g_assert (g_hash_table_size (self->priv->transactions) == 0);
+        g_hash_table_unref (self->priv->transactions);
+    }
+
+    g_hash_table_unref (self->priv->registered_clients);
+
+    if (self->priv->supported_services)
+        g_array_unref (self->priv->supported_services);
+
+    g_free (self->priv->path);
+    g_free (self->priv->path_display);
+    if (self->priv->watch_id)
+        g_source_remove (self->priv->watch_id);
+    if (self->priv->response)
+        g_byte_array_unref (self->priv->response);
+    if (self->priv->iochannel)
+        g_io_channel_unref (self->priv->iochannel);
+
+    G_OBJECT_CLASS (qmi_device_parent_class)->finalize (object);
+}
+
+static void
+async_initable_iface_init (GAsyncInitableIface *iface)
+{
+    iface->init_async = initable_init_async;
+    iface->init_finish = initable_init_finish;
+}
+
+static void
+qmi_device_class_init (QmiDeviceClass *klass)
+{
+    GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+    g_type_class_add_private (object_class, sizeof (QmiDevicePrivate));
+
+    object_class->get_property = get_property;
+    object_class->set_property = set_property;
+    object_class->finalize = finalize;
+    object_class->dispose = dispose;
+
+    properties[PROP_FILE] =
+        g_param_spec_object (QMI_DEVICE_FILE,
+                             "Device file",
+                             "File to the underlying QMI device",
+                             G_TYPE_FILE,
+                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+    g_object_class_install_property (object_class, PROP_FILE, properties[PROP_FILE]);
+}
diff --git a/src/libqmi-glib/qmi-device.h b/src/libqmi-glib/qmi-device.h
new file mode 100644
index 0000000..2912552
--- /dev/null
+++ b/src/libqmi-glib/qmi-device.h
@@ -0,0 +1,199 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_DEVICE_H_
+#define _LIBQMI_GLIB_QMI_DEVICE_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+#include <glib-object.h>
+#include <gio/gio.h>
+
+#include "qmi-enums.h"
+#include "qmi-message.h"
+#include "qmi-client.h"
+
+G_BEGIN_DECLS
+
+#define QMI_TYPE_DEVICE            (qmi_device_get_type ())
+#define QMI_DEVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), QMI_TYPE_DEVICE, QmiDevice))
+#define QMI_DEVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass),  QMI_TYPE_DEVICE, QmiDeviceClass))
+#define QMI_IS_DEVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), QMI_TYPE_DEVICE))
+#define QMI_IS_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass),  QMI_TYPE_DEVICE))
+#define QMI_DEVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj),  QMI_TYPE_DEVICE, QmiDeviceClass))
+
+typedef struct _QmiDevice QmiDevice;
+typedef struct _QmiDeviceClass QmiDeviceClass;
+typedef struct _QmiDevicePrivate QmiDevicePrivate;
+
+#define QMI_DEVICE_FILE "device-file"
+
+/**
+ * QmiDevice:
+ *
+ * The #QmiDevice structure contains private data and should only be accessed
+ * using the provided API.
+ */
+struct _QmiDevice {
+    /*< private >*/
+    GObject parent;
+    QmiDevicePrivate *priv;
+};
+
+struct _QmiDeviceClass {
+    /*< private >*/
+    GObjectClass parent;
+};
+
+GType qmi_device_get_type (void);
+
+void       qmi_device_new       (GFile *file,
+                                 GCancellable *cancellable,
+                                 GAsyncReadyCallback callback,
+                                 gpointer user_data);
+QmiDevice *qmi_device_new_finish (GAsyncResult *res,
+                                  GError **error);
+
+GFile        *qmi_device_get_file         (QmiDevice *self);
+GFile        *qmi_device_peek_file        (QmiDevice *self);
+const gchar  *qmi_device_get_path         (QmiDevice *self);
+const gchar  *qmi_device_get_path_display (QmiDevice *self);
+gboolean      qmi_device_is_open          (QmiDevice *self);
+
+/**
+ * QmiDeviceOpenFlags:
+ * @QMI_DEVICE_OPEN_FLAGS_NONE: No flags.
+ * @QMI_DEVICE_OPEN_FLAGS_VERSION_INFO: Run version info check when opening.
+ * @QMI_DEVICE_OPEN_FLAGS_SYNC: Synchronize with endpoint once the device is open. Will release any previously allocated client ID.
+ * @QMI_DEVICE_OPEN_FLAGS_NET_802_3: set network port to "802.3" mode; mutually exclusive with @QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP
+ * @QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP: set network port to "raw IP" mode; mutally exclusive with @QMI_DEVICE_OPEN_FLAGS_NET_802_3
+ * @QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER: set network port to transmit/receive QoS headers; mutually exclusive with @QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER
+ * @QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER: set network port to not transmit/receive QoS headers; mutually exclusive with @QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER
+ *
+ * Flags to specify which actions to be performed when the device is open.
+ */
+typedef enum {
+    QMI_DEVICE_OPEN_FLAGS_NONE              = 0,
+    QMI_DEVICE_OPEN_FLAGS_VERSION_INFO      = 1 << 0,
+    QMI_DEVICE_OPEN_FLAGS_SYNC              = 1 << 1,
+    QMI_DEVICE_OPEN_FLAGS_NET_802_3         = 1 << 2,
+    QMI_DEVICE_OPEN_FLAGS_NET_RAW_IP        = 1 << 3,
+    QMI_DEVICE_OPEN_FLAGS_NET_QOS_HEADER    = 1 << 4,
+    QMI_DEVICE_OPEN_FLAGS_NET_NO_QOS_HEADER = 1 << 5
+} QmiDeviceOpenFlags;
+
+void         qmi_device_open        (QmiDevice *self,
+                                     QmiDeviceOpenFlags flags,
+                                     guint timeout,
+                                     GCancellable *cancellable,
+                                     GAsyncReadyCallback callback,
+                                     gpointer user_data);
+gboolean     qmi_device_open_finish (QmiDevice *self,
+                                     GAsyncResult *res,
+                                     GError **error);
+
+gboolean     qmi_device_close (QmiDevice *self,
+                               GError **error);
+
+void          qmi_device_allocate_client        (QmiDevice *self,
+                                                 QmiService service,
+                                                 guint8 cid,
+                                                 guint timeout,
+                                                 GCancellable *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+QmiClient    *qmi_device_allocate_client_finish (QmiDevice *self,
+                                                 GAsyncResult *res,
+                                                 GError **error);
+
+/**
+ * QmiDeviceReleaseClientFlags:
+ * @QMI_DEVICE_RELEASE_CLIENT_FLAGS_NONE: No flags.
+ * @QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID: Release the CID when releasing the client.
+ *
+ * Flags to specify which actions to be performed when releasing the client.
+ */
+typedef enum {
+    QMI_DEVICE_RELEASE_CLIENT_FLAGS_NONE        = 0,
+    QMI_DEVICE_RELEASE_CLIENT_FLAGS_RELEASE_CID = 1 << 0
+} QmiDeviceReleaseClientFlags;
+
+void          qmi_device_release_client        (QmiDevice *self,
+                                                QmiClient *client,
+                                                QmiDeviceReleaseClientFlags flags,
+                                                guint timeout,
+                                                GCancellable *cancellable,
+                                                GAsyncReadyCallback callback,
+                                                gpointer user_data);
+gboolean      qmi_device_release_client_finish (QmiDevice *self,
+                                                GAsyncResult *res,
+                                                GError **error);
+
+void          qmi_device_set_instance_id        (QmiDevice *self,
+                                                 guint8 instance_id,
+                                                 guint timeout,
+                                                 GCancellable *cancellable,
+                                                 GAsyncReadyCallback callback,
+                                                 gpointer user_data);
+gboolean      qmi_device_set_instance_id_finish (QmiDevice *self,
+                                                 GAsyncResult *res,
+                                                 guint16 *link_id,
+                                                 GError **error);
+
+void         qmi_device_command        (QmiDevice *self,
+                                        QmiMessage *message,
+                                        guint timeout,
+                                        GCancellable *cancellable,
+                                        GAsyncReadyCallback callback,
+                                        gpointer user_data);
+QmiMessage  *qmi_device_command_finish (QmiDevice *self,
+                                        GAsyncResult *res,
+                                        GError **error);
+
+/**
+ * QmiDeviceServiceVersionInfo:
+ * @service: a #QmiService.
+ * @major_version: major version of the service.
+ * @minor_version: minor version of the service.
+ *
+ * Version information for a service.
+ */
+typedef struct {
+    QmiService service;
+    guint16 major_version;
+    guint16 minor_version;
+} QmiDeviceServiceVersionInfo;
+
+void    qmi_device_get_service_version_info        (QmiDevice *self,
+                                                    guint timeout,
+                                                    GCancellable *cancellable,
+                                                    GAsyncReadyCallback callback,
+                                                    gpointer user_data);
+GArray *qmi_device_get_service_version_info_finish (QmiDevice *self,
+                                                    GAsyncResult *res,
+                                                    GError **error);
+
+G_END_DECLS
+
+#endif /* _LIBQMI_GLIB_QMI_DEVICE_H_ */
diff --git a/src/libqmi-glib/qmi-enums-dms.h b/src/libqmi-glib/qmi-enums-dms.h
new file mode 100644
index 0000000..3476c4d
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-dms.h
@@ -0,0 +1,341 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Lanedo GmbH <aleksander@lanedo.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_DMS_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_DMS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-dms
+ * @title: DMS enumerations and flags
+ *
+ * This section defines enumerations and flags used in the DMS service
+ * interface.
+ */
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Capabilities' message */
+
+/**
+ * QmiDmsDataServiceCapability:
+ * @QMI_DMS_DATA_SERVICE_CAPABILITY_NONE: No data services supported.
+ * @QMI_DMS_DATA_SERVICE_CAPABILITY_CS: Only CS supported.
+ * @QMI_DMS_DATA_SERVICE_CAPABILITY_PS: Only PS supported.
+ * @QMI_DMS_DATA_SERVICE_CAPABILITY_SIMULTANEOUS_CS_PS: Simultaneous CS and PS supported.
+ * @QMI_DMS_DATA_SERVICE_CAPABILITY_NON_SIMULTANEOUS_CS_PS: Non simultaneous CS and PS supported.
+ *
+ * Data service capability.
+ */
+typedef enum {
+    QMI_DMS_DATA_SERVICE_CAPABILITY_NONE                   = 0,
+    QMI_DMS_DATA_SERVICE_CAPABILITY_CS                     = 1,
+    QMI_DMS_DATA_SERVICE_CAPABILITY_PS                     = 2,
+    QMI_DMS_DATA_SERVICE_CAPABILITY_SIMULTANEOUS_CS_PS     = 3,
+    QMI_DMS_DATA_SERVICE_CAPABILITY_NON_SIMULTANEOUS_CS_PS = 4
+} QmiDmsDataServiceCapability;
+
+/**
+ * QmiDmsSimCapability:
+ * @QMI_DMS_SIM_CAPABILITY_NOT_SUPPORTED: SIM not supported.
+ * @QMI_DMS_SIM_CAPABILITY_SUPPORTED: SIM is supported.
+ *
+ * SIM capability.
+ */
+typedef enum {
+    QMI_DMS_SIM_CAPABILITY_NOT_SUPPORTED = 1,
+    QMI_DMS_SIM_CAPABILITY_SUPPORTED     = 2
+} QmiDmsSimCapability;
+
+/**
+ * QmiDmsRadioInterface:
+ * @QMI_DMS_RADIO_INTERFACE_CDMA20001X: CDMA2000 1x.
+ * @QMI_DMS_RADIO_INTERFACE_EVDO: CDMA2000 HRPD (1xEV-DO)
+ * @QMI_DMS_RADIO_INTERFACE_GSM: GSM.
+ * @QMI_DMS_RADIO_INTERFACE_UMTS: UMTS.
+ * @QMI_DMS_RADIO_INTERFACE_LTE: LTE.
+ *
+ * Radio interface type.
+ */
+typedef enum {
+    QMI_DMS_RADIO_INTERFACE_CDMA20001X = 1,
+    QMI_DMS_RADIO_INTERFACE_EVDO       = 2,
+    QMI_DMS_RADIO_INTERFACE_GSM        = 4,
+    QMI_DMS_RADIO_INTERFACE_UMTS       = 5,
+    QMI_DMS_RADIO_INTERFACE_LTE        = 8
+} QmiDmsRadioInterface;
+
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Power State' message */
+
+/**
+ * QmiDmsPowerState:
+ * @QMI_DMS_POWER_STATE_EXTERNAL_SOURCE: Powered by an external source.
+ * @QMI_DMS_POWER_STATE_BATTERY_CONNECTED: Battery is connected.
+ * @QMI_DMS_POWER_STATE_BATTERY_CHARGING: Battery is currently being charged.
+ * @QMI_DMS_POWER_STATE_FAULT: Recognized power fault.
+ *
+ * Flags specifying the current power state.
+ *
+ * If @QMI_DMS_POWER_STATE_EXTERNAL_SOURCE is set, the device is powerered by an
+ * external source; otherwise it is powered by a battery.
+ *
+ * If @QMI_DMS_POWER_STATE_BATTERY_CONNECTED is set, the battery is connected;
+ * otherwise the battery is not connected.
+ *
+ * If @QMI_DMS_POWER_STATE_BATTERY_CHARGING is set, the battery is being charged;
+ * otherwise the battery is not being charged.
+ *
+ * If @QMI_DMS_POWER_STATE_FAULT is set, a power fault has been detected.
+ */
+typedef enum {
+    QMI_DMS_POWER_STATE_EXTERNAL_SOURCE   = 1 << 0,
+    QMI_DMS_POWER_STATE_BATTERY_CONNECTED = 1 << 1,
+    QMI_DMS_POWER_STATE_BATTERY_CHARGING  = 1 << 2,
+    QMI_DMS_POWER_STATE_FAULT             = 1 << 3,
+} QmiDmsPowerState;
+
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS UIM Set PIN Protection' message */
+
+/**
+ * QmiDmsUimPinId:
+ * @QMI_DMS_UIM_PIN_ID_PIN: PIN.
+ * @QMI_DMS_UIM_PIN_ID_PIN2: PIN2.
+ *
+ * The PIN identifier.
+ */
+typedef enum {
+    QMI_DMS_UIM_PIN_ID_PIN  = 1,
+    QMI_DMS_UIM_PIN_ID_PIN2 = 2
+} QmiDmsUimPinId;
+
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS UIM Get PIN Status' message */
+
+/**
+ * QmiDmsUimPinStatus:
+ * @QMI_DMS_UIM_PIN_STATUS_NOT_INITIALIZED: Not initialized.
+ * @QMI_DMS_UIM_PIN_STATUS_ENABLED_NOT_VERIFIED: Enabled, not verified.
+ * @QMI_DMS_UIM_PIN_STATUS_ENABLED_VERIFIED: Enabled, verified.
+ * @QMI_DMS_UIM_PIN_STATUS_DISABLED: Disabled.
+ * @QMI_DMS_UIM_PIN_STATUS_BLOCKED: Blocked.
+ * @QMI_DMS_UIM_PIN_STATUS_PERMANENTLY_BLOCKED: Permanently Blocked.
+ * @QMI_DMS_UIM_PIN_STATUS_UNBLOCKED: Unblocked.
+ * @QMI_DMS_UIM_PIN_STATUS_CHANGED: Changed.
+ *
+ * The PIN status.
+ */
+typedef enum {
+    QMI_DMS_UIM_PIN_STATUS_NOT_INITIALIZED      = 0,
+    QMI_DMS_UIM_PIN_STATUS_ENABLED_NOT_VERIFIED = 1,
+    QMI_DMS_UIM_PIN_STATUS_ENABLED_VERIFIED     = 2,
+    QMI_DMS_UIM_PIN_STATUS_DISABLED             = 3,
+    QMI_DMS_UIM_PIN_STATUS_BLOCKED              = 4,
+    QMI_DMS_UIM_PIN_STATUS_PERMANENTLY_BLOCKED  = 5,
+    QMI_DMS_UIM_PIN_STATUS_UNBLOCKED            = 6,
+    QMI_DMS_UIM_PIN_STATUS_CHANGED              = 7,
+} QmiDmsUimPinStatus;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Operating Mode' message */
+
+/**
+ * QmiDmsOperatingMode:
+ * @QMI_DMS_OPERATING_MODE_ONLINE: Device can acquire a system and make calls.
+ * @QMI_DMS_OPERATING_MODE_LOW_POWER: Device has temporarily disabled RF.
+ * @QMI_DMS_OPERATING_MODE_PERSISTENT_LOW_POWER: Device has disabled RF and state persists even after a reset.
+ * @QMI_DMS_OPERATING_MODE_FACTORY_TEST: Special mode for manufacturer tests.
+ * @QMI_DMS_OPERATING_MODE_OFFLINE: Device has deactivated RF and is partially shutdown.
+ * @QMI_DMS_OPERATING_MODE_RESET: Device is in the process of power cycling.
+ * @QMI_DMS_OPERATING_MODE_SHUTTING_DOWN: Device is in the process of shutting down.
+ * @QMI_DMS_OPERATING_MODE_MODE_ONLY_LOW_POWER: Mode-only Low Power.
+ * @QMI_DMS_OPERATING_MODE_UNKNOWN: Unknown.
+ *
+ * Operating mode of the device.
+ */
+typedef enum {
+    QMI_DMS_OPERATING_MODE_ONLINE                = 0,
+    QMI_DMS_OPERATING_MODE_LOW_POWER             = 1,
+    QMI_DMS_OPERATING_MODE_FACTORY_TEST          = 2,
+    QMI_DMS_OPERATING_MODE_OFFLINE               = 3,
+    QMI_DMS_OPERATING_MODE_RESET                 = 4,
+    QMI_DMS_OPERATING_MODE_SHUTTING_DOWN         = 5,
+    QMI_DMS_OPERATING_MODE_PERSISTENT_LOW_POWER  = 6,
+    QMI_DMS_OPERATING_MODE_MODE_ONLY_LOW_POWER   = 7,
+    QMI_DMS_OPERATING_MODE_UNKNOWN               = 0xFF
+} QmiDmsOperatingMode;
+
+/**
+ * QmiDmsOfflineReason:
+ * @QMI_DMS_OFFLINE_REASON_HOST_IMAGE_MISCONFIGURATION: Host image misconfiguration.
+ * @QMI_DMS_OFFLINE_REASON_PRI_IMAGE_MISCONFIGURATION: PRI image misconfiguration.
+ * @QMI_DMS_OFFLINE_REASON_PRI_VERSION_INCOMPATIBLE: PRI version incompatible.
+ * @QMI_DMS_OFFLINE_REASON_DEVICE_MEMORY_FULL: Memory full, cannot copy PRI information.
+ *
+ * Reasons for being in Offline (@QMI_DMS_OPERATING_MODE_OFFLINE) state.
+ */
+typedef enum {
+    QMI_DMS_OFFLINE_REASON_HOST_IMAGE_MISCONFIGURATION = 1 << 0,
+    QMI_DMS_OFFLINE_REASON_PRI_IMAGE_MISCONFIGURATION  = 1 << 1,
+    QMI_DMS_OFFLINE_REASON_PRI_VERSION_INCOMPATIBLE    = 1 << 2,
+    QMI_DMS_OFFLINE_REASON_DEVICE_MEMORY_FULL          = 1 << 3
+} QmiDmsOfflineReason;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Time' message */
+
+/**
+ * QmiDmsTimeSource:
+ * @QMI_DMS_TIME_SOURCE_DEVICE: 32 kHz device clock.
+ * @QMI_DMS_TIME_SOURCE_CDMA_NETWORK: CDMA network.
+ * @QMI_DMS_TIME_SOURCE_HDR_NETWORK: HDR network.
+ *
+ * Source of the timestamp.
+ */
+typedef enum {
+    QMI_DMS_TIME_SOURCE_DEVICE        = 0,
+    QMI_DMS_TIME_SOURCE_CDMA_NETWORK  = 1,
+    QMI_DMS_TIME_SOURCE_HDR_NETWORK   = 2,
+} QmiDmsTimeSource;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Activation State' message */
+
+/**
+ * QmiDmsActivationState:
+ * @QMI_DMS_ACTIVATION_STATE_NOT_ACTIVATED: Service not activated.
+ * @QMI_DMS_ACTIVATION_STATE_ACTIVATED: Service is activated.
+ * @QMI_DMS_ACTIVATION_STATE_CONNECTING: Connection in progress for automatic activation.
+ * @QMI_DMS_ACTIVATION_STATE_CONNECTED: Connection connected for automatic activation.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_AUTHENTICATED: OTASP security authenticated.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_NAM: OTASP NAM downloaded.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_MDN: OTASP MDN downloaded.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_IMSI: OTASP IMSI downloaded.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_PRL: OTASP PRL downloaded.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_SPC: OTASP SPC downloaded.
+ * @QMI_DMS_ACTIVATION_STATE_OTASP_COMMITED: OTASP settings committed.
+ *
+ * State of the service activation.
+ */
+typedef enum {
+    QMI_DMS_ACTIVATION_STATE_NOT_ACTIVATED       = 0x00,
+    QMI_DMS_ACTIVATION_STATE_ACTIVATED           = 0x01,
+    QMI_DMS_ACTIVATION_STATE_CONNECTING          = 0x02,
+    QMI_DMS_ACTIVATION_STATE_CONNECTED           = 0x03,
+    QMI_DMS_ACTIVATION_STATE_OTASP_AUTHENTICATED = 0x04,
+    QMI_DMS_ACTIVATION_STATE_OTASP_NAM           = 0x05,
+    QMI_DMS_ACTIVATION_STATE_OTASP_MDN           = 0x06,
+    QMI_DMS_ACTIVATION_STATE_OTASP_IMSI          = 0x07,
+    QMI_DMS_ACTIVATION_STATE_OTASP_PRL           = 0x08,
+    QMI_DMS_ACTIVATION_STATE_OTASP_SPC           = 0x09,
+    QMI_DMS_ACTIVATION_STATE_OTASP_COMMITED      = 0x0A
+} QmiDmsActivationState;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS UIM Get CK Status' message */
+
+/**
+ * QmiDmsUimFacility:
+ * @QMI_DMS_UIM_FACILITY_PN: Network personalization facility.
+ * @QMI_DMS_UIM_FACILITY_PU: Network subset personalization facility.
+ * @QMI_DMS_UIM_FACILITY_PP: Service provider facility.
+ * @QMI_DMS_UIM_FACILITY_PC: Corporate personalization facility.
+ * @QMI_DMS_UIM_FACILITY_PF: UIM personalization facility.
+ *
+ * UIM personalization facilities.
+ */
+typedef enum {
+    QMI_DMS_UIM_FACILITY_PN = 0,
+    QMI_DMS_UIM_FACILITY_PU = 1,
+    QMI_DMS_UIM_FACILITY_PP = 2,
+    QMI_DMS_UIM_FACILITY_PC = 3,
+    QMI_DMS_UIM_FACILITY_PF = 4
+} QmiDmsUimFacility;
+
+/**
+ * QmiDmsUimFacilityState:
+ * @QMI_DMS_UIM_FACILITY_STATE_DEACTIVATED: Facility is deactivated.
+ * @QMI_DMS_UIM_FACILITY_STATE_ACTIVATED: Facility is activated.
+ * @QMI_DMS_UIM_FACILITY_STATE_BLOCKED: Facility is blocked.
+ */
+typedef enum {
+    QMI_DMS_UIM_FACILITY_STATE_DEACTIVATED = 0,
+    QMI_DMS_UIM_FACILITY_STATE_ACTIVATED   = 1,
+    QMI_DMS_UIM_FACILITY_STATE_BLOCKED     = 2
+} QmiDmsUimFacilityState;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS UIM Get State' message */
+
+/**
+ * QmiDmsUimState:
+ * @QMI_DMS_UIM_STATE_INITIALIZATION_COMPLETED: UIM initialization completed.
+ * @QMI_DMS_UIM_STATE_LOCKED_OR_FAILED: UIM is locked or failed.
+ * @QMI_DMS_UIM_STATE_NOT_PRESENT: No UIM in the device.
+ * @QMI_DMS_UIM_STATE_RESERVED: Reserved, unknown.
+ * @QMI_DMS_UIM_STATE_UNKNOWN: UIM state currently unavailable.
+ *
+ * State of the UIM.
+ */
+typedef enum {
+    QMI_DMS_UIM_STATE_INITIALIZATION_COMPLETED = 0x00,
+    QMI_DMS_UIM_STATE_LOCKED_OR_FAILED         = 0x01,
+    QMI_DMS_UIM_STATE_NOT_PRESENT              = 0x02,
+    QMI_DMS_UIM_STATE_RESERVED                 = 0x03,
+    QMI_DMS_UIM_STATE_UNKNOWN                  = 0xFF
+} QmiDmsUimState;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Set Time' message */
+
+/**
+ * QmiDmsTimeReferenceType:
+ * @QMI_DMS_TIME_REFERENCE_TYPE_USER: User time.
+ *
+ * Time reference type.
+ */
+typedef enum {
+    QMI_DMS_TIME_REFERENCE_TYPE_USER = 0
+} QmiDmsTimeReferenceType;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Firmware Preference' message */
+
+/**
+ * QmiDmsFirmwareImageType:
+ * @QMI_DMS_FIRMWARE_IMAGE_TYPE_MODEM: Modem image.
+ * @QMI_DMS_FIRMWARE_IMAGE_TYPE_PRI: PRI image.
+ *
+ * Type of firmware image.
+ */
+typedef enum {
+    QMI_DMS_FIRMWARE_IMAGE_TYPE_MODEM = 0,
+    QMI_DMS_FIRMWARE_IMAGE_TYPE_PRI   = 1
+} QmiDmsFirmwareImageType;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_DMS_H_ */
diff --git a/src/libqmi-glib/qmi-enums-nas.h b/src/libqmi-glib/qmi-enums-nas.h
new file mode 100644
index 0000000..0b333d1
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-nas.h
@@ -0,0 +1,875 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_NAS_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_NAS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-nas
+ * @title: NAS enumerations and flags
+ *
+ * This section defines enumerations and flags used in the NAS service
+ * interface.
+ */
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Event Report' indication */
+
+/**
+ * QmiNasRadioInterface:
+ * @QMI_NAS_RADIO_INTERFACE_UNKNOWN: Not known or not needed.
+ * @QMI_NAS_RADIO_INTERFACE_NONE: None, no service.
+ * @QMI_NAS_RADIO_INTERFACE_CDMA_1X: CDMA2000 1X.
+ * @QMI_NAS_RADIO_INTERFACE_CDMA_1XEVDO: CDMA2000 HRPD (1xEV-DO).
+ * @QMI_NAS_RADIO_INTERFACE_AMPS: AMPS.
+ * @QMI_NAS_RADIO_INTERFACE_GSM: GSM.
+ * @QMI_NAS_RADIO_INTERFACE_UMTS: UMTS.
+ * @QMI_NAS_RADIO_INTERFACE_LTE: LTE.
+ * @QMI_NAS_RADIO_INTERFACE_TD_SCDMA: TD-SCDMA.
+ *
+ * Radio interface technology.
+ */
+typedef enum {
+    QMI_NAS_RADIO_INTERFACE_UNKNOWN     = -1,
+    QMI_NAS_RADIO_INTERFACE_NONE        = 0x00,
+    QMI_NAS_RADIO_INTERFACE_CDMA_1X     = 0x01,
+    QMI_NAS_RADIO_INTERFACE_CDMA_1XEVDO = 0x02,
+    QMI_NAS_RADIO_INTERFACE_AMPS        = 0x03,
+    QMI_NAS_RADIO_INTERFACE_GSM         = 0x04,
+    QMI_NAS_RADIO_INTERFACE_UMTS        = 0x05,
+    QMI_NAS_RADIO_INTERFACE_LTE         = 0x08,
+    QMI_NAS_RADIO_INTERFACE_TD_SCDMA    = 0x09
+} QmiNasRadioInterface;
+
+/**
+ * QmiNasActiveBand:
+ * @QMI_NAS_ACTIVE_BAND_BC_0: Band class 0.
+ * @QMI_NAS_ACTIVE_BAND_BC_1: Band class 1.
+ * @QMI_NAS_ACTIVE_BAND_BC_2: Band class 2.
+ * @QMI_NAS_ACTIVE_BAND_BC_3: Band class 3.
+ * @QMI_NAS_ACTIVE_BAND_BC_4: Band class 4.
+ * @QMI_NAS_ACTIVE_BAND_BC_5: Band class 5.
+ * @QMI_NAS_ACTIVE_BAND_BC_6: Band class 6.
+ * @QMI_NAS_ACTIVE_BAND_BC_7: Band class 7.
+ * @QMI_NAS_ACTIVE_BAND_BC_8: Band class 8.
+ * @QMI_NAS_ACTIVE_BAND_BC_9: Band class 9.
+ * @QMI_NAS_ACTIVE_BAND_BC_10: Band class 10.
+ * @QMI_NAS_ACTIVE_BAND_BC_11: Band class 11.
+ * @QMI_NAS_ACTIVE_BAND_BC_12: Band class 12.
+ * @QMI_NAS_ACTIVE_BAND_BC_13: Band class 13.
+ * @QMI_NAS_ACTIVE_BAND_BC_14: Band class 14.
+ * @QMI_NAS_ACTIVE_BAND_BC_15: Band class 15.
+ * @QMI_NAS_ACTIVE_BAND_BC_16: Band class 16.
+ * @QMI_NAS_ACTIVE_BAND_BC_17: Band class 17.
+ * @QMI_NAS_ACTIVE_BAND_BC_18: Band class 18.
+ * @QMI_NAS_ACTIVE_BAND_BC_19: Band class 19.
+ * @QMI_NAS_ACTIVE_BAND_GSM_450: GSM 450.
+ * @QMI_NAS_ACTIVE_BAND_GSM_480: GSM 480.
+ * @QMI_NAS_ACTIVE_BAND_GSM_750: GSM 750.
+ * @QMI_NAS_ACTIVE_BAND_GSM_850: GSM 850.
+ * @QMI_NAS_ACTIVE_BAND_GSM_900_EXTENDED: GSM 900 (Extended).
+ * @QMI_NAS_ACTIVE_BAND_GSM_900_PRIMARY: GSM 900 (Primary).
+ * @QMI_NAS_ACTIVE_BAND_GSM_900_RAILWAYS: GSM 900 (Railways).
+ * @QMI_NAS_ACTIVE_BAND_GSM_DCS_1800: GSM 1800.
+ * @QMI_NAS_ACTIVE_BAND_GSM_PCS_1900: GSM 1900.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_2100: WCDMA 2100.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_PCS_1900: WCDMA PCS 1900.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_DCS_1800: WCDMA DCS 1800.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_1700_US: WCDMA 1700 (U.S.).
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_850: WCDMA 850.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_800: WCDMA 800.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_2600: WCDMA 2600.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_900: WCDMA 900.
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_1700_JAPAN: WCDMA 1700 (Japan).
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_1500_JAPAN: WCDMA 1500 (Japan).
+ * @QMI_NAS_ACTIVE_BAND_WCDMA_850_JAPAN: WCDMA 850 (Japan).
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_1: EUTRAN band 1.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_2: EUTRAN band 2.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_3: EUTRAN band 3.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_4: EUTRAN band 4.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_5: EUTRAN band 5.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_6: EUTRAN band 6.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_7: EUTRAN band 7.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_8: EUTRAN band 8.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_9: EUTRAN band 9.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_10: EUTRAN band 10.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_11: EUTRAN band 11.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_12: EUTRAN band 12.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_13: EUTRAN band 13.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_14: EUTRAN band 14.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_17: EUTRAN band 17.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_18: EUTRAN band 18.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_19: EUTRAN band 19.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_20: EUTRAN band 20.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_21: EUTRAN band 21.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_24: EUTRAN band 24.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_25: EUTRAN band 25.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_33: EUTRAN band 33.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_34: EUTRAN band 34.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_35: EUTRAN band 35.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_36: EUTRAN band 36.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_37: EUTRAN band 37.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_38: EUTRAN band 38.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_39: EUTRAN band 39.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_40: EUTRAN band 40.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_41: EUTRAN band 41.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_42: EUTRAN band 42.
+ * @QMI_NAS_ACTIVE_BAND_EUTRAN_43: EUTRAN band 43.
+ * @QMI_NAS_ACTIVE_BAND_TDSCDMA_A: TD-SCDMA Band A.
+ * @QMI_NAS_ACTIVE_BAND_TDSCDMA_B: TD-SCDMA Band B.
+ * @QMI_NAS_ACTIVE_BAND_TDSCDMA_C: TD-SCDMA Band C.
+ * @QMI_NAS_ACTIVE_BAND_TDSCDMA_D: TD-SCDMA Band D.
+ * @QMI_NAS_ACTIVE_BAND_TDSCDMA_E: TD-SCDMA Band E.
+ * @QMI_NAS_ACTIVE_BAND_TDSCDMA_F: TD-SCDMA Band F.
+ *
+ * Band classes.
+ */
+typedef enum {
+    QMI_NAS_ACTIVE_BAND_BC_0 = 0,
+    QMI_NAS_ACTIVE_BAND_BC_1 = 1,
+    QMI_NAS_ACTIVE_BAND_BC_2 = 2,
+    QMI_NAS_ACTIVE_BAND_BC_3 = 3,
+    QMI_NAS_ACTIVE_BAND_BC_4 = 4,
+    QMI_NAS_ACTIVE_BAND_BC_5 = 5,
+    QMI_NAS_ACTIVE_BAND_BC_6 = 6,
+    QMI_NAS_ACTIVE_BAND_BC_7 = 7,
+    QMI_NAS_ACTIVE_BAND_BC_8 = 8,
+    QMI_NAS_ACTIVE_BAND_BC_9 = 9,
+    QMI_NAS_ACTIVE_BAND_BC_10 = 10,
+    QMI_NAS_ACTIVE_BAND_BC_11 = 11,
+    QMI_NAS_ACTIVE_BAND_BC_12 = 12,
+    QMI_NAS_ACTIVE_BAND_BC_13 = 13,
+    QMI_NAS_ACTIVE_BAND_BC_14 = 14,
+    QMI_NAS_ACTIVE_BAND_BC_15 = 15,
+    QMI_NAS_ACTIVE_BAND_BC_16 = 16,
+    QMI_NAS_ACTIVE_BAND_BC_17 = 17,
+    QMI_NAS_ACTIVE_BAND_BC_18 = 18,
+    QMI_NAS_ACTIVE_BAND_BC_19 = 19,
+    QMI_NAS_ACTIVE_BAND_GSM_450 = 40,
+    QMI_NAS_ACTIVE_BAND_GSM_480 = 41,
+    QMI_NAS_ACTIVE_BAND_GSM_750 = 42,
+    QMI_NAS_ACTIVE_BAND_GSM_850 = 43,
+    QMI_NAS_ACTIVE_BAND_GSM_900_EXTENDED = 44,
+    QMI_NAS_ACTIVE_BAND_GSM_900_PRIMARY = 45,
+    QMI_NAS_ACTIVE_BAND_GSM_900_RAILWAYS = 46,
+    QMI_NAS_ACTIVE_BAND_GSM_DCS_1800 = 47,
+    QMI_NAS_ACTIVE_BAND_GSM_PCS_1900 = 48,
+    QMI_NAS_ACTIVE_BAND_WCDMA_2100 = 80,
+    QMI_NAS_ACTIVE_BAND_WCDMA_PCS_1900 = 81,
+    QMI_NAS_ACTIVE_BAND_WCDMA_DCS_1800 = 82,
+    QMI_NAS_ACTIVE_BAND_WCDMA_1700_US = 83,
+    QMI_NAS_ACTIVE_BAND_WCDMA_850 = 84,
+    QMI_NAS_ACTIVE_BAND_WCDMA_800 = 85,
+    QMI_NAS_ACTIVE_BAND_WCDMA_2600 = 86,
+    QMI_NAS_ACTIVE_BAND_WCDMA_900 = 87,
+    QMI_NAS_ACTIVE_BAND_WCDMA_1700_JAPAN = 88,
+    QMI_NAS_ACTIVE_BAND_WCDMA_1500_JAPAN = 90,
+    QMI_NAS_ACTIVE_BAND_WCDMA_850_JAPAN = 91,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_1 = 120,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_2 = 121,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_3 = 122,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_4 = 123,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_5 = 124,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_6 = 125,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_7 = 126,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_8 = 127,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_9 = 128,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_10 = 129,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_11 = 130,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_12 = 131,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_13 = 132,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_14 = 133,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_17 = 134,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_18 = 143,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_19 = 144,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_20 = 145,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_21 = 146,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_24 = 147,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_25 = 148,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_33 = 135,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_34 = 136,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_35 = 137,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_36 = 138,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_37 = 139,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_38 = 140,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_39 = 141,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_40 = 142,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_41 = 149,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_42 = 150,
+    QMI_NAS_ACTIVE_BAND_EUTRAN_43 = 151,
+    QMI_NAS_ACTIVE_BAND_TDSCDMA_A = 200,
+    QMI_NAS_ACTIVE_BAND_TDSCDMA_B = 201,
+    QMI_NAS_ACTIVE_BAND_TDSCDMA_C = 202,
+    QMI_NAS_ACTIVE_BAND_TDSCDMA_D = 203,
+    QMI_NAS_ACTIVE_BAND_TDSCDMA_E = 204,
+    QMI_NAS_ACTIVE_BAND_TDSCDMA_F = 205
+} QmiNasActiveBand;
+
+/**
+ * QmiNasNetworkServiceDomain:
+ * @QMI_NAS_NETWORK_SERVICE_DOMAIN_NONE: No service.
+ * @QMI_NAS_NETWORK_SERVICE_DOMAIN_CS: Circuit switched.
+ * @QMI_NAS_NETWORK_SERVICE_DOMAIN_PS: Packet switched.
+ * @QMI_NAS_NETWORK_SERVICE_DOMAIN_CS_PS: Circuit and packet switched.
+ * @QMI_NAS_NETWORK_SERVICE_DOMAIN_UNKNOWN: Unknown service.
+ *
+ * Network Service Domain.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_SERVICE_DOMAIN_NONE    = 0x00,
+    QMI_NAS_NETWORK_SERVICE_DOMAIN_CS      = 0x01,
+    QMI_NAS_NETWORK_SERVICE_DOMAIN_PS      = 0x02,
+    QMI_NAS_NETWORK_SERVICE_DOMAIN_CS_PS   = 0x03,
+    QMI_NAS_NETWORK_SERVICE_DOMAIN_UNKNOWN = 0x04,
+} QmiNasNetworkServiceDomain;
+
+/**
+ * QmiNasEvdoSinrLevel:
+ * @QMI_NAS_EVDO_SINR_LEVEL_0: -9 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_1: -6 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_2: -4.5 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_3: -3 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_4: -2 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_5: +1 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_6: +3 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_7: +6 dB.
+ * @QMI_NAS_EVDO_SINR_LEVEL_8: +9 dB.
+ *
+ * EV-DO SINR level.
+ */
+typedef enum {
+    QMI_NAS_EVDO_SINR_LEVEL_0 = 0,
+    QMI_NAS_EVDO_SINR_LEVEL_1 = 1,
+    QMI_NAS_EVDO_SINR_LEVEL_2 = 2,
+    QMI_NAS_EVDO_SINR_LEVEL_3 = 3,
+    QMI_NAS_EVDO_SINR_LEVEL_4 = 4,
+    QMI_NAS_EVDO_SINR_LEVEL_5 = 5,
+    QMI_NAS_EVDO_SINR_LEVEL_6 = 6,
+    QMI_NAS_EVDO_SINR_LEVEL_7 = 7,
+    QMI_NAS_EVDO_SINR_LEVEL_8 = 8
+} QmiNasEvdoSinrLevel;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get Signal Strength' request/response */
+
+/**
+ * QmiNasSignalStrengthRequest:
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_NONE: None.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSSI: Request RSSI information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_ECIO: Request ECIO information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_IO: Request IO information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_SINR: Request SINR information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_ERROR_RATE: Request error rate information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSRQ: Request RSRQ information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_SNR: Request LTE SNR information.
+ * @QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_RSRP: Request LTE RSRP information.
+ *
+ * Extra information to request when gathering Signal Strength.
+ */
+typedef enum {
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_NONE       = 0,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSSI       = 1 << 0,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_ECIO       = 1 << 1,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_IO         = 1 << 2,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_SINR       = 1 << 3,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_ERROR_RATE = 1 << 4,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_RSRQ       = 1 << 5,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_SNR    = 1 << 6,
+    QMI_NAS_SIGNAL_STRENGTH_REQUEST_LTE_RSRP   = 1 << 7
+} QmiNasSignalStrengthRequest;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Network Scan' request/response */
+
+/**
+ * QmiNasNetworkScanType:
+ * @QMI_NAS_NETWORK_SCAN_TYPE_GSM: GSM network.
+ * @QMI_NAS_NETWORK_SCAN_TYPE_UMTS: UMTS network.
+ * @QMI_NAS_NETWORK_SCAN_TYPE_LTE: LTE network.
+ * @QMI_NAS_NETWORK_SCAN_TYPE_TD_SCDMA: TD-SCDMA network.
+ *
+ * Flags to use when specifying which networks to scan.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_SCAN_TYPE_GSM      = 1 << 0,
+    QMI_NAS_NETWORK_SCAN_TYPE_UMTS     = 1 << 1,
+    QMI_NAS_NETWORK_SCAN_TYPE_LTE      = 1 << 2,
+    QMI_NAS_NETWORK_SCAN_TYPE_TD_SCDMA = 1 << 3
+} QmiNasNetworkScanType;
+
+/**
+ * QmiNasNetworkStatus:
+ * @QMI_NAS_NETWORK_STATUS_CURRENT_SERVING: Network is in use, current serving.
+ * @QMI_NAS_NETWORK_STATUS_AVAILABLE: Network is vailable.
+ * @QMI_NAS_NETWORK_STATUS_HOME: Network is home network.
+ * @QMI_NAS_NETWORK_STATUS_ROAMING: Network is a roaming network.
+ * @QMI_NAS_NETWORK_STATUS_FORBIDDEN: Network is forbidden.
+ * @QMI_NAS_NETWORK_STATUS_NOT_FORBIDDEN: Network is not forbidden.
+ * @QMI_NAS_NETWORK_STATUS_PREFERRED: Network is preferred.
+ * @QMI_NAS_NETWORK_STATUS_NOT_PREFERRED: Network is not preferred.
+ *
+ * Flags to specify the status of a given network.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_STATUS_CURRENT_SERVING = 1 << 0,
+    QMI_NAS_NETWORK_STATUS_AVAILABLE       = 1 << 1,
+    QMI_NAS_NETWORK_STATUS_HOME            = 1 << 2,
+    QMI_NAS_NETWORK_STATUS_ROAMING         = 1 << 3,
+    QMI_NAS_NETWORK_STATUS_FORBIDDEN       = 1 << 4,
+    QMI_NAS_NETWORK_STATUS_NOT_FORBIDDEN   = 1 << 5,
+    QMI_NAS_NETWORK_STATUS_PREFERRED       = 1 << 6,
+    QMI_NAS_NETWORK_STATUS_NOT_PREFERRED   = 1 << 7
+} QmiNasNetworkStatus;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Initiate Network Register' request/response */
+
+/**
+ * QmiNasNetworkRegisterType:
+ * @QMI_NAS_NETWORK_REGISTER_TYPE_AUTOMATIC: Automatic network registration.
+ * @QMI_NAS_NETWORK_REGISTER_TYPE_MANUAL: Manual network registration.
+ *
+ * Type of network registration.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_REGISTER_TYPE_AUTOMATIC = 0x01,
+    QMI_NAS_NETWORK_REGISTER_TYPE_MANUAL    = 0x02
+} QmiNasNetworkRegisterType;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get Serving System' request/response */
+
+/**
+ * QmiNasRegistrationState:
+ * @QMI_NAS_REGISTRATION_STATE_NOT_REGISTERED: Not registered.
+ * @QMI_NAS_REGISTRATION_STATE_REGISTERED: Registered.
+ * @QMI_NAS_REGISTRATION_STATE_NOT_REGISTERED_SEARCHING: Searching.
+ * @QMI_NAS_REGISTRATION_STATE_REGISTRATION_DENIED: Registration denied.
+ * @QMI_NAS_REGISTRATION_STATE_UNKNOWN: Unknown.
+ *
+ * Status of the network registration.
+ */
+typedef enum {
+    QMI_NAS_REGISTRATION_STATE_NOT_REGISTERED           = 0x00,
+    QMI_NAS_REGISTRATION_STATE_REGISTERED               = 0x01,
+    QMI_NAS_REGISTRATION_STATE_NOT_REGISTERED_SEARCHING = 0x02,
+    QMI_NAS_REGISTRATION_STATE_REGISTRATION_DENIED      = 0x03,
+    QMI_NAS_REGISTRATION_STATE_UNKNOWN                  = 0x04
+} QmiNasRegistrationState;
+
+/**
+ * QmiNasAttachState:
+ * @QMI_NAS_ATTACH_STATE_UNKNOWN: Unknown attach state.
+ * @QMI_NAS_ATTACH_STATE_ATTACHED: Attached.
+ * @QMI_NAS_ATTACH_STATE_DETACHED: Detached.
+ *
+ * Domain attach state.
+ */
+typedef enum {
+    QMI_NAS_ATTACH_STATE_UNKNOWN  = 0x00,
+    QMI_NAS_ATTACH_STATE_ATTACHED = 0x01,
+    QMI_NAS_ATTACH_STATE_DETACHED = 0x02,
+} QmiNasAttachState;
+
+/**
+ * QmiNasNetworkType:
+ * @QMI_NAS_NETWORK_TYPE_UNKNOWN: Unknown.
+ * @QMI_NAS_NETWORK_TYPE_3GPP2: 3GPP2 network.
+ * @QMI_NAS_NETWORK_TYPE_3GPP: 3GPP network.
+ *
+ * Type of network.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_TYPE_UNKNOWN = 0x00,
+    QMI_NAS_NETWORK_TYPE_3GPP2   = 0x01,
+    QMI_NAS_NETWORK_TYPE_3GPP    = 0x02,
+} QmiNasNetworkType;
+
+/**
+ * QmiNasRoamingIndicatorStatus:
+ * @QMI_NAS_ROAMING_INDICATOR_STATUS_ON: Roaming.
+ * @QMI_NAS_ROAMING_INDICATOR_STATUS_OFF: Home.
+ *
+ * Status of the roaming indication.
+ */
+typedef enum {
+    QMI_NAS_ROAMING_INDICATOR_STATUS_ON  = 0x00,
+    QMI_NAS_ROAMING_INDICATOR_STATUS_OFF = 0x01,
+    /* next values only for 3GPP2 */
+} QmiNasRoamingIndicatorStatus;
+
+/**
+ * QmiNasDataCapability:
+ * @QMI_NAS_DATA_CAPABILITY_NONE: None or unknown.
+ * @QMI_NAS_DATA_CAPABILITY_GPRS: GPRS.
+ * @QMI_NAS_DATA_CAPABILITY_EDGE: EDGE.
+ * @QMI_NAS_DATA_CAPABILITY_HSDPA: HSDPA.
+ * @QMI_NAS_DATA_CAPABILITY_HSUPA: HSUPA.
+ * @QMI_NAS_DATA_CAPABILITY_WCDMA: WCDMA.
+ * @QMI_NAS_DATA_CAPABILITY_CDMA: CDMA.
+ * @QMI_NAS_DATA_CAPABILITY_EVDO_REV_0: EV-DO revision 0.
+ * @QMI_NAS_DATA_CAPABILITY_EVDO_REV_A: EV-DO revision A.
+ * @QMI_NAS_DATA_CAPABILITY_GSM: GSM.
+ * @QMI_NAS_DATA_CAPABILITY_EVDO_REV_B: EV-DO revision B.
+ * @QMI_NAS_DATA_CAPABILITY_LTE: LTE.
+ * @QMI_NAS_DATA_CAPABILITY_HSDPA_PLUS: HSDPA+.
+ * @QMI_NAS_DATA_CAPABILITY_DC_HSDPA_PLUS: DC-HSDPA+.
+ *
+ * Data capability of the network.
+ */
+typedef enum {
+    QMI_NAS_DATA_CAPABILITY_NONE          = 0x00,
+    QMI_NAS_DATA_CAPABILITY_GPRS          = 0x01,
+    QMI_NAS_DATA_CAPABILITY_EDGE          = 0x02,
+    QMI_NAS_DATA_CAPABILITY_HSDPA         = 0x03,
+    QMI_NAS_DATA_CAPABILITY_HSUPA         = 0x04,
+    QMI_NAS_DATA_CAPABILITY_WCDMA         = 0x05,
+    QMI_NAS_DATA_CAPABILITY_CDMA          = 0x06,
+    QMI_NAS_DATA_CAPABILITY_EVDO_REV_0    = 0x07,
+    QMI_NAS_DATA_CAPABILITY_EVDO_REV_A    = 0x08,
+    QMI_NAS_DATA_CAPABILITY_GSM           = 0x09,
+    QMI_NAS_DATA_CAPABILITY_EVDO_REV_B    = 0x0A,
+    QMI_NAS_DATA_CAPABILITY_LTE           = 0x0B,
+    QMI_NAS_DATA_CAPABILITY_HSDPA_PLUS    = 0x0C,
+    QMI_NAS_DATA_CAPABILITY_DC_HSDPA_PLUS = 0x0D
+} QmiNasDataCapability;
+
+/**
+ * QmiNasServiceStatus:
+ * @QMI_NAS_SERVICE_STATUS_NONE: No service.
+ * @QMI_NAS_SERVICE_STATUS_LIMITED: Limited service.
+ * @QMI_NAS_SERVICE_STATUS_AVAILABLE: Service available.
+ * @QMI_NAS_SERVICE_STATUS_LIMITED_REGIONAL: Limited regional service.
+ * @QMI_NAS_SERVICE_STATUS_POWER_SAVE: Device in power save mode.
+ *
+ * Status of the service.
+ */
+typedef enum {
+    QMI_NAS_SERVICE_STATUS_NONE             = 0x00,
+    QMI_NAS_SERVICE_STATUS_LIMITED          = 0x01,
+    QMI_NAS_SERVICE_STATUS_AVAILABLE        = 0x02,
+    QMI_NAS_SERVICE_STATUS_LIMITED_REGIONAL = 0x03,
+    QMI_NAS_SERVICE_STATUS_POWER_SAVE       = 0x04
+} QmiNasServiceStatus;
+
+/**
+ * QmiNasHdrPersonality:
+ * @QMI_NAS_HDR_PERSONALITY_UNKNOWN: Unknown.
+ * @QMI_NAS_HDR_PERSONALITY_HRPD: HRPD.
+ * @QMI_NAS_HDR_PERSONALITY_EHRPD: eHRPD.
+ *
+ * HDR personality type.
+ */
+typedef enum {
+    QMI_NAS_HDR_PERSONALITY_UNKNOWN = 0x00,
+    QMI_NAS_HDR_PERSONALITY_HRPD    = 0x01,
+    QMI_NAS_HDR_PERSONALITY_EHRPD   = 0x02,
+} QmiNasHdrPersonality;
+
+/**
+ * QmiNasCallBarringStatus:
+ * @QMI_NAS_CALL_BARRING_STATUS_NORMAL_ONLY: Normal calls only.
+ * @QMI_NAS_CALL_BARRING_STATUS_EMERGENCY_ONLY: Emergency calls only.
+ * @QMI_NAS_CALL_BARRING_STATUS_NO_CALLS: No calls allowed.
+ * @QMI_NAS_CALL_BARRING_STATUS_ALL_CALLS: All calls allowed.
+ * @QMI_NAS_CALL_BARRING_STATUS_UNKNOWN: Unknown.
+ *
+ * Status of the call barring functionality.
+ */
+typedef enum {
+    QMI_NAS_CALL_BARRING_STATUS_NORMAL_ONLY    = 0x00,
+    QMI_NAS_CALL_BARRING_STATUS_EMERGENCY_ONLY = 0x01,
+    QMI_NAS_CALL_BARRING_STATUS_NO_CALLS       = 0x02,
+    QMI_NAS_CALL_BARRING_STATUS_ALL_CALLS      = 0x03,
+    QMI_NAS_CALL_BARRING_STATUS_UNKNOWN        = -1
+} QmiNasCallBarringStatus;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get Home Network' request/response */
+
+/**
+ * QmiNasNetworkDescriptionDisplay:
+ * @QMI_NAS_NETWORK_DESCRIPTION_DISPLAY_NO: Don't display.
+ * @QMI_NAS_NETWORK_DESCRIPTION_DISPLAY_YES: Display.
+ * @QMI_NAS_NETWORK_DESCRIPTION_DISPLAY_UNKNOWN: Unknown.
+ *
+ * Setup to define whether the network description should be displayed.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_DESCRIPTION_DISPLAY_NO      = 0x00,
+    QMI_NAS_NETWORK_DESCRIPTION_DISPLAY_YES     = 0x01,
+    QMI_NAS_NETWORK_DESCRIPTION_DISPLAY_UNKNOWN = 0xFF
+} QmiNasNetworkDescriptionDisplay;
+
+/**
+ * QmiNasNetworkDescriptionEncoding:
+ * @QMI_NAS_NETWORK_DESCRIPTION_ENCODING_UNSPECIFIED: Unspecified.
+ * @QMI_NAS_NETWORK_DESCRIPTION_ENCODING_ASCII7: ASCII-7.
+ * @QMI_NAS_NETWORK_DESCRIPTION_ENCODING_UNICODE: Unicode.
+ * @QMI_NAS_NETWORK_DESCRIPTION_ENCODING_GSM: GSM 7-bit.
+ *
+ * Type of encoding used in the network description.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_DESCRIPTION_ENCODING_UNSPECIFIED = 0x00,
+    QMI_NAS_NETWORK_DESCRIPTION_ENCODING_ASCII7      = 0x01,
+    QMI_NAS_NETWORK_DESCRIPTION_ENCODING_UNICODE     = 0x04,
+    QMI_NAS_NETWORK_DESCRIPTION_ENCODING_GSM         = 0x09
+} QmiNasNetworkDescriptionEncoding;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get Technology Preference' request/response */
+
+/**
+ * QmiNasRadioTechnologyPreference:
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AUTO: Automatic selection.
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP2: 3GPP2 technology.
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP: 3GPP technology.
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AMPS_OR_GSM: AMPS if 3GPP2, GSM if 3GPP.
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_CDMA_OR_WCDMA: CDMA if 3GPP2, WCDMA if 3GPP.
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_HDR: CDMA EV-DO.
+ * @QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_LTE: LTE.
+ *
+ * Flags to specify the radio technology preference.
+ */
+typedef enum {
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AUTO          = 0,
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP2         = 1 << 0,
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_3GPP          = 1 << 1,
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_AMPS_OR_GSM   = 1 << 2,
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_CDMA_OR_WCDMA = 1 << 3,
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_HDR           = 1 << 4,
+    QMI_NAS_RADIO_TECHNOLOGY_PREFERENCE_LTE           = 1 << 5
+} QmiNasRadioTechnologyPreference;
+
+/**
+ * QmiNasPreferenceDuration:
+ * @QMI_NAS_PREFERENCE_DURATION_PERMANENT: Permanent.
+ * @QMI_NAS_PREFERENCE_DURATION_POWER_CYCLE: Until the next power cycle.
+ * @QMI_NAS_PREFERENCE_DURATION_ONE_CALL: Until end of call.
+ * @QMI_NAS_PREFERENCE_DURATION_ONE_CALL_OR_TIME: Until end of call or a specified time.
+ * @QMI_NAS_PREFERENCE_DURATION_INTERNAL_ONE_CALL_1: Internal reason 1, one call.
+ * @QMI_NAS_PREFERENCE_DURATION_INTERNAL_ONE_CALL_2: Internal reason 2, one call.
+ * @QMI_NAS_PREFERENCE_DURATION_INTERNAL_ONE_CALL_3: Internal reason 3, one call.
+ *
+ * Duration of the preference setting.
+ */
+typedef enum {
+    QMI_NAS_PREFERENCE_DURATION_PERMANENT           = 0x00,
+    QMI_NAS_PREFERENCE_DURATION_POWER_CYCLE         = 0x01,
+    QMI_NAS_PREFERENCE_DURATION_ONE_CALL            = 0x02,
+    QMI_NAS_PREFERENCE_DURATION_ONE_CALL_OR_TIME    = 0x03,
+    QMI_NAS_PREFERENCE_DURATION_INTERNAL_ONE_CALL_1 = 0x04,
+    QMI_NAS_PREFERENCE_DURATION_INTERNAL_ONE_CALL_2 = 0x05,
+    QMI_NAS_PREFERENCE_DURATION_INTERNAL_ONE_CALL_3 = 0x06
+} QmiNasPreferenceDuration;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get/Set System Selection Preference'
+ * requests/responses */
+
+/**
+ * QmiNasRatModePreference:
+ * @QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1X: CDMA2000 1X.
+ * @QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1XEVDO: CDMA2000 HRPD (1xEV-DO).
+ * @QMI_NAS_RAT_MODE_PREFERENCE_GSM: GSM.
+ * @QMI_NAS_RAT_MODE_PREFERENCE_UMTS: UMTS.
+ * @QMI_NAS_RAT_MODE_PREFERENCE_LTE: LTE.
+ * @QMI_NAS_RAT_MODE_PREFERENCE_TD_SCDMA: TD-SCDMA.
+ *
+ * Flags specifying radio access technology mode preference.
+ */
+typedef enum {
+    QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1X     = 1 << 0,
+    QMI_NAS_RAT_MODE_PREFERENCE_CDMA_1XEVDO = 1 << 1,
+    QMI_NAS_RAT_MODE_PREFERENCE_GSM         = 1 << 2,
+    QMI_NAS_RAT_MODE_PREFERENCE_UMTS        = 1 << 3,
+    QMI_NAS_RAT_MODE_PREFERENCE_LTE         = 1 << 4,
+    QMI_NAS_RAT_MODE_PREFERENCE_TD_SCDMA    = 1 << 5
+} QmiNasRatModePreference;
+
+/**
+ * QmiNasCdmaPrlPreference:
+ * @QMI_NAS_CDMA_PRL_PREFERENCE_A_SIDE_ONLY: System A only.
+ * @QMI_NAS_CDMA_PRL_PREFERENCE_B_SIDE_ONLY: System B only.
+ * @QMI_NAS_CDMA_PRL_PREFERENCE_ANY: Any system.
+ *
+ * Flags specifying the preference when using CDMA Band Class 0.
+ */
+typedef enum {
+    QMI_NAS_CDMA_PRL_PREFERENCE_A_SIDE_ONLY = 0x0001,
+    QMI_NAS_CDMA_PRL_PREFERENCE_B_SIDE_ONLY = 0x0002,
+    QMI_NAS_CDMA_PRL_PREFERENCE_ANY         = 0x3FFF
+} QmiNasCdmaPrlPreference;
+
+/**
+ * QmiNasRoamingPreference:
+ * @QMI_NAS_ROAMING_PREFERENCE_OFF: Only non-roaming networks.
+ * @QMI_NAS_ROAMING_PREFERENCE_NOT_OFF: Only roaming networks.
+ * @QMI_NAS_ROAMING_PREFERENCE_NOT_FLASHING: Only non-roaming networks or not flashing.
+ * @QMI_NAS_ROAMING_PREFERENCE_ANY: Don't filter by roaming when acquiring networks.
+ *
+ * Roaming preference.
+ */
+typedef enum {
+    QMI_NAS_ROAMING_PREFERENCE_OFF          = 0x01,
+    QMI_NAS_ROAMING_PREFERENCE_NOT_OFF      = 0x02,
+    QMI_NAS_ROAMING_PREFERENCE_NOT_FLASHING = 0x03,
+    QMI_NAS_ROAMING_PREFERENCE_ANY          = 0xFF
+} QmiNasRoamingPreference;
+
+/**
+ * QmiNasNetworkSelectionPreference:
+ * @QMI_NAS_NETWORK_SELECTION_PREFERENCE_AUTOMATIC: Automatic.
+ * @QMI_NAS_NETWORK_SELECTION_PREFERENCE_MANUAL: Manual.
+ *
+ * Network selection preference.
+ */
+typedef enum {
+    QMI_NAS_NETWORK_SELECTION_PREFERENCE_AUTOMATIC = 0x00,
+    QMI_NAS_NETWORK_SELECTION_PREFERENCE_MANUAL    = 0x01
+} QmiNasNetworkSelectionPreference;
+
+/**
+ * QmiNasChangeDuration:
+ * @QMI_NAS_CHANGE_DURATION_PERMANENT: Permanent.
+ * @QMI_NAS_CHANGE_DURATION_POWER_CYCLE: Until the next power cycle.
+ *
+ * Duration of the change setting.
+ */
+typedef enum {
+    QMI_NAS_CHANGE_DURATION_POWER_CYCLE = 0x00,
+    QMI_NAS_CHANGE_DURATION_PERMANENT   = 0x01
+} QmiNasChangeDuration;
+
+/**
+ * QmiNasServiceDomainPreference:
+ * @QMI_NAS_SERVICE_DOMAIN_PREFERENCE_CS_ONLY: Circuit-switched only.
+ * @QMI_NAS_SERVICE_DOMAIN_PREFERENCE_PS_ONLY: Packet-switched only.
+ * @QMI_NAS_SERVICE_DOMAIN_PREFERENCE_CS_PS: Circuit-switched and packet-switched.
+ * @QMI_NAS_SERVICE_DOMAIN_PREFERENCE_PS_ATTACH: Packet-switched attach.
+ * @QMI_NAS_SERVICE_DOMAIN_PREFERENCE_PS_DETACH:Packet-switched dettach.
+ *
+ * Service domain preference.
+ */
+typedef enum {
+    QMI_NAS_SERVICE_DOMAIN_PREFERENCE_CS_ONLY   = 0x00,
+    QMI_NAS_SERVICE_DOMAIN_PREFERENCE_PS_ONLY   = 0x01,
+    QMI_NAS_SERVICE_DOMAIN_PREFERENCE_CS_PS     = 0x02,
+    QMI_NAS_SERVICE_DOMAIN_PREFERENCE_PS_ATTACH = 0x03,
+    QMI_NAS_SERVICE_DOMAIN_PREFERENCE_PS_DETACH = 0x04,
+} QmiNasServiceDomainPreference;
+
+/**
+ * QmiNasGsmWcdmaAcquisitionOrderPreference:
+ * @QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_AUTOMATIC: Automatic.
+ * @QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_GSM: GSM first, then WCDMA.
+ * @QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_WCDMA: WCDMA first, then GSM.
+ *
+ * GSM/WCDMA acquisition order preference.
+ */
+typedef enum {
+    QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_AUTOMATIC = 0x00,
+    QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_GSM       = 0x01,
+    QMI_NAS_GSM_WCDMA_ACQUISITION_ORDER_PREFERENCE_WCDMA     = 0x02
+} QmiNasGsmWcdmaAcquisitionOrderPreference;
+
+/**
+ * QmiNasTdScdmaBandPreference:
+ * @QMI_NAS_TD_SCDMA_BAND_PREFERENCE_A: Band A.
+ * @QMI_NAS_TD_SCDMA_BAND_PREFERENCE_B: Band B.
+ * @QMI_NAS_TD_SCDMA_BAND_PREFERENCE_C: Band C.
+ * @QMI_NAS_TD_SCDMA_BAND_PREFERENCE_D: Band D.
+ * @QMI_NAS_TD_SCDMA_BAND_PREFERENCE_E: Band E.
+ * @QMI_NAS_TD_SCDMA_BAND_PREFERENCE_F: Band F.
+ *
+ * Flags to specify TD-SCDMA-specific frequency band preferences.
+ */
+typedef enum {
+    QMI_NAS_TD_SCDMA_BAND_PREFERENCE_A = 1 << 0,
+    QMI_NAS_TD_SCDMA_BAND_PREFERENCE_B = 1 << 1,
+    QMI_NAS_TD_SCDMA_BAND_PREFERENCE_C = 1 << 2,
+    QMI_NAS_TD_SCDMA_BAND_PREFERENCE_D = 1 << 3,
+    QMI_NAS_TD_SCDMA_BAND_PREFERENCE_E = 1 << 4,
+    QMI_NAS_TD_SCDMA_BAND_PREFERENCE_F = 1 << 5
+} QmiNasTdScdmaBandPreference;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get System Info' request/response */
+
+/**
+ * QmiNasRoamingStatus:
+ * @QMI_NAS_ROAMING_STATUS_OFF: Off.
+ * @QMI_NAS_ROAMING_STATUS_ON: On.
+ * @QMI_NAS_ROAMING_STATUS_BLINK: Blinking.
+ * @QMI_NAS_ROAMING_STATUS_OUT_OF_NEIGHBORHOOD: Out of neighborhood.
+ * @QMI_NAS_ROAMING_STATUS_OUT_OF_BUILDING: Out of building.
+ * @QMI_NAS_ROAMING_STATUS_PREFERRED_SYSTEM: Preferred system.
+ * @QMI_NAS_ROAMING_STATUS_AVAILABLE_SYSTEM: Available system.
+ * @QMI_NAS_ROAMING_STATUS_ALLIANCE_PARTNER: Alliance partner.
+ * @QMI_NAS_ROAMING_STATUS_PREMIUM_PARTNER: Premium partner.
+ * @QMI_NAS_ROAMING_STATUS_FULL_SERVICE: Full service.
+ * @QMI_NAS_ROAMING_STATUS_PARTIAL_SERVICE: Partial service.
+ * @QMI_NAS_ROAMING_STATUS_BANNER_ON: Banner on.
+ * @QMI_NAS_ROAMING_STATUS_BANNER_OFF: Banner off.
+*/
+typedef enum {
+    QMI_NAS_ROAMING_STATUS_OFF                 = 0x00,
+    QMI_NAS_ROAMING_STATUS_ON                  = 0x01,
+    /* Next ones only for 3GPP2 */
+    QMI_NAS_ROAMING_STATUS_BLINK               = 0x02,
+    QMI_NAS_ROAMING_STATUS_OUT_OF_NEIGHBORHOOD = 0x03,
+    QMI_NAS_ROAMING_STATUS_OUT_OF_BUILDING     = 0x04,
+    QMI_NAS_ROAMING_STATUS_PREFERRED_SYSTEM    = 0x05,
+    QMI_NAS_ROAMING_STATUS_AVAILABLE_SYSTEM    = 0x06,
+    QMI_NAS_ROAMING_STATUS_ALLIANCE_PARTNER    = 0x07,
+    QMI_NAS_ROAMING_STATUS_PREMIUM_PARTNER     = 0x08,
+    QMI_NAS_ROAMING_STATUS_FULL_SERVICE        = 0x09,
+    QMI_NAS_ROAMING_STATUS_PARTIAL_SERVICE     = 0x0A,
+    QMI_NAS_ROAMING_STATUS_BANNER_ON           = 0x0B,
+    QMI_NAS_ROAMING_STATUS_BANNER_OFF          = 0x0C
+} QmiNasRoamingStatus;
+
+/**
+ * QmiNasHdrProtocolRevision:
+ * @QMI_NAS_HDR_PROTOCOL_REVISION_NONE: None.
+ * @QMI_NAS_HDR_PROTOCOL_REVISION_REL_0: HDR Rel 0.
+ * @QMI_NAS_HDR_PROTOCOL_REVISION_REL_A: HDR Rel A.
+ * @QMI_NAS_HDR_PROTOCOL_REVISION_REL_B: HDR Rel B.
+ *
+ * HDR protocol revision.
+ */
+typedef enum {
+    QMI_NAS_HDR_PROTOCOL_REVISION_NONE  = 0x00,
+    QMI_NAS_HDR_PROTOCOL_REVISION_REL_0 = 0x01,
+    QMI_NAS_HDR_PROTOCOL_REVISION_REL_A = 0x02,
+    QMI_NAS_HDR_PROTOCOL_REVISION_REL_B = 0x03
+} QmiNasHdrProtocolRevision;
+
+/**
+ * QmiNasWcdmaHsService:
+ * @QMI_NAS_WCDMA_HS_SERVICE_HSDPA_HSUPA_UNSUPPORTED: HSDPA and HSUPA not supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_HSDPA_SUPPORTED: HSDPA supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_HSUPA_SUPPORTED: HSUPA supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_HSDPA_HSUPA_SUPPORTED: HSDPA and HSUPA supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_HSDPA_PLUS_SUPPORTED: HSDPA+ supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_HSDPA_PLUS_HSUPA_SUPPORTED: HSDPA+ and HSUPA supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_DC_HSDPA_PLUS_SUPPORTED: DC-HSDPA+ supported.
+ * @QMI_NAS_WCDMA_HS_SERVICE_DC_HSDPA_PLUS_HSUPA_SUPPORTED: DC-HSDPA+ and HSUPA supported.
+ * Call status on high speed.
+ */
+typedef enum {
+    QMI_NAS_WCDMA_HS_SERVICE_HSDPA_HSUPA_UNSUPPORTED       = 0x00,
+    QMI_NAS_WCDMA_HS_SERVICE_HSDPA_SUPPORTED               = 0x01,
+    QMI_NAS_WCDMA_HS_SERVICE_HSUPA_SUPPORTED               = 0x02,
+    QMI_NAS_WCDMA_HS_SERVICE_HSDPA_HSUPA_SUPPORTED         = 0x03,
+    QMI_NAS_WCDMA_HS_SERVICE_HSDPA_PLUS_SUPPORTED          = 0x04,
+    QMI_NAS_WCDMA_HS_SERVICE_HSDPA_PLUS_HSUPA_SUPPORTED    = 0x05,
+    QMI_NAS_WCDMA_HS_SERVICE_DC_HSDPA_PLUS_SUPPORTED       = 0x06,
+    QMI_NAS_WCDMA_HS_SERVICE_DC_HSDPA_PLUS_HSUPA_SUPPORTED = 0x07
+} QmiNasWcdmaHsService;
+
+/**
+ * QmiNasCellBroadcastCapability:
+ * @QMI_NAS_CELL_BROADCAST_CAPABILITY_UNKNOWN: Unknown.
+ * @QMI_NAS_CELL_BROADCAST_CAPABILITY_OFF: Cell broadcast not supported.
+ * @QMI_NAS_CELL_BROADCAST_CAPABILITY_ON: Cell broadcast supported.
+ *
+ * Cell broadcast support.
+ */
+typedef enum {
+    QMI_NAS_CELL_BROADCAST_CAPABILITY_UNKNOWN = 0x00,
+    QMI_NAS_CELL_BROADCAST_CAPABILITY_OFF     = 0x01,
+    QMI_NAS_CELL_BROADCAST_CAPABILITY_ON      = 0x02
+} QmiNasCellBroadcastCapability;
+
+/**
+ * QmiNasSimRejectState:
+ * @QMI_NAS_SIM_REJECT_STATE_SIM_UNAVAILABLE: SIM not available.
+ * @QMI_NAS_SIM_REJECT_STATE_SIM_VAILABLE: SIM available.
+ * @QMI_NAS_SIM_REJECT_STATE_SIM_CS_INVALID: SIM invalid for circuit-switched connections.
+ * @QMI_NAS_SIM_REJECT_STATE_SIM_PS_INVALID: SIM invalid for packet-switched connections.
+ * @QMI_NAS_SIM_REJECT_STATE_SIM_CS_PS_INVALID: SIM invalid for circuit-switched and packet-switched connections.
+ *
+ * Reject information of the SIM.
+ */
+typedef enum {
+    QMI_NAS_SIM_REJECT_STATE_SIM_UNAVAILABLE   = 0,
+    QMI_NAS_SIM_REJECT_STATE_SIM_VAILABLE      = 1,
+    QMI_NAS_SIM_REJECT_STATE_SIM_CS_INVALID    = 2,
+    QMI_NAS_SIM_REJECT_STATE_SIM_PS_INVALID    = 3,
+    QMI_NAS_SIM_REJECT_STATE_SIM_CS_PS_INVALID = 4
+} QmiNasSimRejectState;
+
+/**
+ * QmiNasCdmaPilotType:
+ * @QMI_NAS_CDMA_PILOT_TYPE_ACTIVE: the pilot is part of the active set.
+ * @QMI_NAS_CDMA_PILOT_TYPE_NEIGHBOR: the pilot is part of the neighbor set.
+ *
+ * The pilot set the pilot belongs to.
+ */
+typedef enum {
+    QMI_NAS_CDMA_PILOT_TYPE_ACTIVE   = 0,
+    QMI_NAS_CDMA_PILOT_TYPE_NEIGHBOR = 1,
+} QmiNasCdmaPilotType;
+
+/**
+ * QmiNasDayOfWeek:
+ * @QMI_NAS_DAY_OF_WEEK_MONDAY: Monday
+ * @QMI_NAS_DAY_OF_WEEK_TUESDAY: Tuesday
+ * @QMI_NAS_DAY_OF_WEEK_WEDNESDAY: Wednesday
+ * @QMI_NAS_DAY_OF_WEEK_THURSDAY: Thursday
+ * @QMI_NAS_DAY_OF_WEEK_FRIDAY: Friday
+ * @QMI_NAS_DAY_OF_WEEK_SATURDAY: Saturday
+ * @QMI_NAS_DAY_OF_WEEK_SUNDAY: Sunday
+ *
+ * The day of the week.
+ */
+typedef enum {
+    QMI_NAS_DAY_OF_WEEK_MONDAY    = 0,
+    QMI_NAS_DAY_OF_WEEK_TUESDAY   = 1,
+    QMI_NAS_DAY_OF_WEEK_WEDNESDAY = 2,
+    QMI_NAS_DAY_OF_WEEK_THURSDAY  = 3,
+    QMI_NAS_DAY_OF_WEEK_FRIDAY    = 4,
+    QMI_NAS_DAY_OF_WEEK_SATURDAY  = 5,
+    QMI_NAS_DAY_OF_WEEK_SUNDAY    = 6
+} QmiNasDayOfWeek;
+
+/**
+ * QmiNasDaylightSavingsAdjustment:
+ * @QMI_NAS_DAYLIGHT_SAVINGS_ADJUSTMENT_NONE: no adjustment
+ * @QMI_NAS_DAYLIGHT_SAVINGS_ADJUSTMENT_ONE_HOUR: one hour adjustment
+ * @QMI_NAS_DAYLIGHT_SAVINGS_ADJUSTMENT_TWO_HOURS: two hours adjustment
+ *
+ * The number of hours a time is adjusted for daylight savings.
+ */
+typedef enum {
+    QMI_NAS_DAYLIGHT_SAVINGS_ADJUSTMENT_NONE      = 0,
+    QMI_NAS_DAYLIGHT_SAVINGS_ADJUSTMENT_ONE_HOUR  = 1,
+    QMI_NAS_DAYLIGHT_SAVINGS_ADJUSTMENT_TWO_HOURS = 2
+} QmiNasDaylightSavingsAdjustment;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_NAS_H_ */
diff --git a/src/libqmi-glib/qmi-enums-oma.h b/src/libqmi-glib/qmi-enums-oma.h
new file mode 100644
index 0000000..6d4e826
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-oma.h
@@ -0,0 +1,124 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2013 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_OMA_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_OMA_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-oma
+ * @title: OMA enumerations and flags
+ *
+ * This section defines enumerations and flags used in the OMA service
+ * interface.
+ */
+
+/**
+ * QmiOmaSessionType:
+ * @QMI_OMA_SESSION_TYPE_CLIENT_INITIATED_DEVICE_CONFIGURE: Client-initiated device configure.
+ * @QMI_OMA_SESSION_TYPE_CLIENT_INITIATED_PRL_UPDATE: Client-initiated PRL update.
+ * @QMI_OMA_SESSION_TYPE_CLIENT_INITIATED_HANDS_FREE_ACTIVATION: Client-initiated hands free activation.
+ * @QMI_OMA_SESSION_TYPE_DEVICE_INITIATED_HANDS_FREE_ACTIVATION: Device-initiated hands free activation.
+ * @QMI_OMA_SESSION_TYPE_NETWORK_INITIATED_PRL_UPDATE: Network-initiated PRL update.
+ * @QMI_OMA_SESSION_TYPE_NETWORK_INITIATED_DEVICE_CONFIGURE: Network-initiated device configure.
+ * @QMI_OMA_SESSION_TYPE_DEVICE_INITIATED_PRL_UPDATE: Device-initiated PRL update.
+ *
+ * Type of OMA-DM session.
+ */
+typedef enum {
+    QMI_OMA_SESSION_TYPE_CLIENT_INITIATED_DEVICE_CONFIGURE      = 0,
+    QMI_OMA_SESSION_TYPE_CLIENT_INITIATED_PRL_UPDATE            = 1,
+    QMI_OMA_SESSION_TYPE_CLIENT_INITIATED_HANDS_FREE_ACTIVATION = 2,
+    QMI_OMA_SESSION_TYPE_DEVICE_INITIATED_HANDS_FREE_ACTIVATION = 3,
+    QMI_OMA_SESSION_TYPE_NETWORK_INITIATED_PRL_UPDATE           = 4,
+    QMI_OMA_SESSION_TYPE_NETWORK_INITIATED_DEVICE_CONFIGURE     = 5,
+    QMI_OMA_SESSION_TYPE_DEVICE_INITIATED_PRL_UPDATE            = 6
+} QmiOmaSessionType;
+
+/**
+ * QmiOmaSessionState:
+ * @QMI_OMA_SESSION_STATE_COMPLETE_INFORMATION_UPDATED: Session complete and information updated.
+ * @QMI_OMA_SESSION_STATE_COMPLETE_UPDATED_INFORMATION_UNAVAILABLE: Session complete but updated information not available.
+ * @QMI_OMA_SESSION_STATE_FAILED: Session failed.
+ * @QMI_OMA_SESSION_STATE_RETRYING: Session retrying.
+ * @QMI_OMA_SESSION_STATE_CONNECTING: Session connecting.
+ * @QMI_OMA_SESSION_STATE_CONNECTED: Session connected.
+ * @QMI_OMA_SESSION_STATE_AUTHENTICATED: Session authenticated.
+ * @QMI_OMA_SESSION_STATE_MDN_DOWNLOADED: MDN downloaded.
+ * @QMI_OMA_SESSION_STATE_MSID_DOWNLOADED: MSID downloaded.
+ * @QMI_OMA_SESSION_STATE_PRL_DOWNLOADED: PRL downloaded.
+ * @QMI_OMA_SESSION_STATE_MIP_PROFILE_DOWNLOADED: MIP profile downloaded.
+ *
+ * State of the OMA-DM session.
+ */
+typedef enum {
+    QMI_OMA_SESSION_STATE_COMPLETE_INFORMATION_UPDATED             = 0,
+    QMI_OMA_SESSION_STATE_COMPLETE_UPDATED_INFORMATION_UNAVAILABLE = 1,
+    QMI_OMA_SESSION_STATE_FAILED                                   = 2,
+    QMI_OMA_SESSION_STATE_RETRYING                                 = 3,
+    QMI_OMA_SESSION_STATE_CONNECTING                               = 4,
+    QMI_OMA_SESSION_STATE_CONNECTED                                = 5,
+    QMI_OMA_SESSION_STATE_AUTHENTICATED                            = 6,
+    QMI_OMA_SESSION_STATE_MDN_DOWNLOADED                           = 7,
+    QMI_OMA_SESSION_STATE_MSID_DOWNLOADED                          = 8,
+    QMI_OMA_SESSION_STATE_PRL_DOWNLOADED                           = 9,
+    QMI_OMA_SESSION_STATE_MIP_PROFILE_DOWNLOADED                   = 10
+} QmiOmaSessionState;
+
+/**
+ * QmiOmaSessionFailedReason:
+ * @QMI_OMA_SESSION_FAILED_REASON_UNKNOWN: Unknown reason.
+ * @QMI_OMA_SESSION_FAILED_REASON_NETWORK_UNAVAILABLE: Network unavailable.
+ * @QMI_OMA_SESSION_FAILED_REASON_SERVER_UNAVAILABLE: Server unavailable.
+ * @QMI_OMA_SESSION_FAILED_REASON_AUTHENTICATION_FAILED: Authentication failed.
+ * @QMI_OMA_SESSION_FAILED_REASON_MAX_RETRY_EXCEEDED: Maximum retries exceeded.
+ * @QMI_OMA_SESSION_FAILED_REASON_SESSION_CANCELLED: Session cancelled.
+ *
+ * Session failure reason.
+ */
+typedef enum {
+    QMI_OMA_SESSION_FAILED_REASON_UNKNOWN               = 0,
+    QMI_OMA_SESSION_FAILED_REASON_NETWORK_UNAVAILABLE   = 1,
+    QMI_OMA_SESSION_FAILED_REASON_SERVER_UNAVAILABLE    = 2,
+    QMI_OMA_SESSION_FAILED_REASON_AUTHENTICATION_FAILED = 3,
+    QMI_OMA_SESSION_FAILED_REASON_MAX_RETRY_EXCEEDED    = 4,
+    QMI_OMA_SESSION_FAILED_REASON_SESSION_CANCELLED     = 5
+} QmiOmaSessionFailedReason;
+
+/**
+ * QmiOmaHfaFeatureDoneState:
+ * @QMI_OMA_HFA_FEATURE_DONE_STATE_NONE: None.
+ * @QMI_OMA_HFA_FEATURE_DONE_STATE_SUCCEEDED: Succeeded.
+ * @QMI_OMA_HFA_FEATURE_DONE_STATE_FAILED: Failed.
+ *
+ * HFA feature done state.
+ */
+typedef enum {
+    QMI_OMA_HFA_FEATURE_DONE_STATE_NONE      = 0,
+    QMI_OMA_HFA_FEATURE_DONE_STATE_SUCCEEDED = 1,
+    QMI_OMA_HFA_FEATURE_DONE_STATE_FAILED    = 2
+} QmiOmaHfaFeatureDoneState;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_OMA_H_ */
diff --git a/src/libqmi-glib/qmi-enums-pbm.h b/src/libqmi-glib/qmi-enums-pbm.h
new file mode 100644
index 0000000..2b10872
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-pbm.h
@@ -0,0 +1,112 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_PBM_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_PBM_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-pbm
+ * @title: PBM enumerations and flags
+ *
+ * This section defines enumerations and flags used in the PBM service
+ * interface.
+ */
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI PBM Indication Register' indication */
+
+/**
+ * QmiPbmEventRegistrationFlag:
+ * @QMI_PBM_EVENT_REGISTRATION_FLAG_RECORD_UPDATE: Request indications when records are added/edited/deleted.
+ * @QMI_PBM_EVENT_REGISTRATION_FLAG_PHONEBOOK_READY: Request indications when phonebooks are ready.
+ * @QMI_PBM_EVENT_REGISTRATION_FLAG_EMERGENCY_NUMBER_LIST: Request indications when emergency numbers are changed.
+ * @QMI_PBM_EVENT_REGISTRATION_FLAG_HIDDEN_RECORD_STATUS: Request indications when hidden record status is changed.
+ * @QMI_PBM_EVENT_REGISTRATION_FLAG_AAS_UPDATE: Request indications when Additional number Alpha String records are added/edited/deleted.
+ * @QMI_PBM_EVENT_REGISTRATION_FLAG_GAS_UPDATE: Request indications when Grouping information Alpha String records are added/edited/deleted.
+ *
+ * Flags to use to register to phonebook indications.
+ */
+typedef enum {
+    QMI_PBM_EVENT_REGISTRATION_FLAG_RECORD_UPDATE         = 1 << 0,
+    QMI_PBM_EVENT_REGISTRATION_FLAG_PHONEBOOK_READY       = 1 << 1,
+    QMI_PBM_EVENT_REGISTRATION_FLAG_EMERGENCY_NUMBER_LIST = 1 << 2,
+    QMI_PBM_EVENT_REGISTRATION_FLAG_HIDDEN_RECORD_STATUS  = 1 << 3,
+    QMI_PBM_EVENT_REGISTRATION_FLAG_AAS_UPDATE            = 1 << 4,
+    QMI_PBM_EVENT_REGISTRATION_FLAG_GAS_UPDATE            = 1 << 5,
+} QmiPbmEventRegistrationFlag;
+
+/*****************************************************************************/
+/* Helper enums for the 'Get Capabilities' request */
+
+/**
+ * QmiPbmPhonebookType:
+ * @QMI_PBM_PHONEBOOK_TYPE_ADN: Abbreviated Dialing Number.
+ * @QMI_PBM_PHONEBOOK_TYPE_FDN: Fixed Dialing Number.
+ * @QMI_PBM_PHONEBOOK_TYPE_MSISDN: Mobile Subscriber Integrated Services Digital Network.
+ * @QMI_PBM_PHONEBOOK_TYPE_MBDN: Mail Box Dialing Number.
+ * @QMI_PBM_PHONEBOOK_TYPE_SDN: Service Dialing Number.
+ * @QMI_PBM_PHONEBOOK_TYPE_BDN: Barred Dialing Number.
+ * @QMI_PBM_PHONEBOOK_TYPE_LND: Last Number Dialed.
+ * @QMI_PBM_PHONEBOOK_TYPE_MBN: Mail Box Number.
+ *
+ * Phonebook type.
+ */
+typedef enum {
+    QMI_PBM_PHONEBOOK_TYPE_ADN    = 1 << 0,
+    QMI_PBM_PHONEBOOK_TYPE_FDN    = 1 << 1,
+    QMI_PBM_PHONEBOOK_TYPE_MSISDN = 1 << 2,
+    QMI_PBM_PHONEBOOK_TYPE_MBDN   = 1 << 3,
+    QMI_PBM_PHONEBOOK_TYPE_SDN    = 1 << 4,
+    QMI_PBM_PHONEBOOK_TYPE_BDN    = 1 << 5,
+    QMI_PBM_PHONEBOOK_TYPE_LND    = 1 << 6,
+    QMI_PBM_PHONEBOOK_TYPE_MBN    = 1 << 7,
+} QmiPbmPhonebookType;
+
+/**
+ * QmiPbmSessionType:
+ * @QMI_PBM_SESSION_TYPE_GW_PRIMARY: Access phonebooks under GSM DF (ICC) or USIM application (UICC).
+ * @QMI_PBM_SESSION_TYPE_1X_PRIMARY: Access phonebooks under CDMA DF (ICC) or CSIM application (UICC).
+ * @QMI_PBM_SESSION_TYPE_GW_SECONDARY: Access phonebooks under GSM DF (ICC) or USIM application (UICC). Dual standby.
+ * @QMI_PBM_SESSION_TYPE_1X_SECONDARY: Access phonebooks under CDMA DF (ICC) or CSIM application (UICC). Dual standby.
+ * @QMI_PBM_SESSION_TYPE_NONPROVISIONING_SLOT_1: Access phonebooks under a nonprovisioning application in slot 1.
+ * @QMI_PBM_SESSION_TYPE_NONPROVISIONING_SLOT_2: Access phonebooks under a nonprovisioning application in slot 2.
+ * @QMI_PBM_SESSION_TYPE_GLOBAL_PHONEBOOK_SLOT_1: Access phonebooks that are not in any application of the card in slot 1.
+ * @QMI_PBM_SESSION_TYPE_GLOBAL_PHONEBOOK_SLOT_2: Access phonebooks that are not in any application of the card in slot 2.
+ *
+ * Type of phonebook management session.
+ */
+typedef enum {
+    QMI_PBM_SESSION_TYPE_GW_PRIMARY              = 0,
+    QMI_PBM_SESSION_TYPE_1X_PRIMARY              = 1,
+    QMI_PBM_SESSION_TYPE_GW_SECONDARY            = 2,
+    QMI_PBM_SESSION_TYPE_1X_SECONDARY            = 3,
+    QMI_PBM_SESSION_TYPE_NONPROVISIONING_SLOT_1  = 4,
+    QMI_PBM_SESSION_TYPE_NONPROVISIONING_SLOT_2  = 5,
+    QMI_PBM_SESSION_TYPE_GLOBAL_PHONEBOOK_SLOT_1 = 6,
+    QMI_PBM_SESSION_TYPE_GLOBAL_PHONEBOOK_SLOT_2 = 7,
+} QmiPbmSessionType;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_PBM_H_ */
diff --git a/src/libqmi-glib/qmi-enums-pds.h b/src/libqmi-glib/qmi-enums-pds.h
new file mode 100644
index 0000000..c6382cc
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-pds.h
@@ -0,0 +1,154 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_PDS_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_PDS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-pds
+ * @title: PDS enumerations and flags
+ *
+ * This section defines enumerations and flags used in the PDS service
+ * interface.
+ */
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI PDS Event Report' indication */
+
+/**
+ * QmiPdsOperationMode:
+ * @QMI_PDS_OPERATION_MODE_UNKNOWN: Unknown (position not fixed yet).
+ * @QMI_PDS_OPERATION_MODE_STANDALONE: Standalone.
+ * @QMI_PDS_OPERATION_MODE_MS_BASED: MS based.
+ * @QMI_PDS_OPERATION_MODE_MS_ASSISTED: MS assisted.
+ *
+ * Operation mode used to compute the position.
+ */
+typedef enum {
+    QMI_PDS_OPERATION_MODE_UNKNOWN     = -1,
+    QMI_PDS_OPERATION_MODE_STANDALONE  =  0,
+    QMI_PDS_OPERATION_MODE_MS_BASED    =  1,
+    QMI_PDS_OPERATION_MODE_MS_ASSISTED =  2
+} QmiPdsOperationMode;
+
+/**
+ * QmiPdsPositionSessionStatus:
+ * @QMI_PDS_POSITION_SESSION_STATUS_SUCCESS: Success.
+ * @QMI_PDS_POSITION_SESSION_STATUS_IN_PROGRESS: In progress.
+ * @QMI_PDS_POSITION_SESSION_STATUS_GENERAL_FAILURE: General failure.
+ * @QMI_PDS_POSITION_SESSION_STATUS_TIMEOUT: Timeout.
+ * @QMI_PDS_POSITION_SESSION_STATUS_USER_ENDED_SESSION: User ended session.
+ * @QMI_PDS_POSITION_SESSION_STATUS_BAD_PARAMETER: Bad parameter.
+ * @QMI_PDS_POSITION_SESSION_STATUS_PHONE_OFFLINE: Phone is offline.
+ * @QMI_PDS_POSITION_SESSION_STATUS_ENGINE_LOCKED: Engine locked.
+ * @QMI_PDS_POSITION_SESSION_STATUS_E911_SESSION_IN_PROGRESS: Emergency call in progress.
+ *
+ * Status of the positioning session.
+ */
+typedef enum {
+    QMI_PDS_POSITION_SESSION_STATUS_SUCCESS                  = 0x00,
+    QMI_PDS_POSITION_SESSION_STATUS_IN_PROGRESS              = 0x01,
+    QMI_PDS_POSITION_SESSION_STATUS_GENERAL_FAILURE          = 0x02,
+    QMI_PDS_POSITION_SESSION_STATUS_TIMEOUT                  = 0x03,
+    QMI_PDS_POSITION_SESSION_STATUS_USER_ENDED_SESSION       = 0x04,
+    QMI_PDS_POSITION_SESSION_STATUS_BAD_PARAMETER            = 0x05,
+    QMI_PDS_POSITION_SESSION_STATUS_PHONE_OFFLINE            = 0x06,
+    QMI_PDS_POSITION_SESSION_STATUS_ENGINE_LOCKED            = 0x07,
+    QMI_PDS_POSITION_SESSION_STATUS_E911_SESSION_IN_PROGRESS = 0x08
+} QmiPdsPositionSessionStatus;
+
+/**
+ * QmiPdsDataValid:
+ * @QMI_PDS_DATA_VALID_TIMESTAMP_CALENDAR: Timestamp calendar (GPS time).
+ * @QMI_PDS_DATA_VALID_TIMESTAMP_UTC: Timestamp (UTC).
+ * @QMI_PDS_DATA_VALID_LEAP_SECONDS: Leap seconds.
+ * @QMI_PDS_DATA_VALID_TIME_UNCERTAINTY: Time uncertainty.
+ * @QMI_PDS_DATA_VALID_LATITUDE: Latitude.
+ * @QMI_PDS_DATA_VALID_LONGITUDE: Longitude.
+ * @QMI_PDS_DATA_VALID_ELLIPSOID_ALTITUDE: Ellipsoid altitude.
+ * @QMI_PDS_DATA_VALID_MEAN_SEA_LEVEL_ALTITUDE: Mean sea level altitude.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_SPEED: Horizontal speed.
+ * @QMI_PDS_DATA_VALID_VERTICAL_SPEED: Vertical speed.
+ * @QMI_PDS_DATA_VALID_HEADING: Heading.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_CIRCULAR: Horizontal uncertainty circular.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MAJOR: Horizontal uncertainty ellipse semi-major.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MINOR: Horizontal uncertainty ellipse semi-minor.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_ORIENT_AZIMUTH: Horizontal uncertainty ellipse orient azimuth.
+ * @QMI_PDS_DATA_VALID_VERTICAL_UNCERTAINTY: Vertical uncertainty.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_VELOCITY_UNCERTAINTY: Horizontal velocity uncertainty.
+ * @QMI_PDS_DATA_VALID_VERTICAL_VELOCITY_UNCERTAINTY: Vertical velocity uncertainty.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_CONFIDENCE: Horizontal confidence.
+ * @QMI_PDS_DATA_VALID_POSITION_DOP: Position dillution of precision.
+ * @QMI_PDS_DATA_VALID_HORIZONTAL_DOP: Horizontal dillution of precision.
+ * @QMI_PDS_DATA_VALID_VERTICAL_DOP: Vertical dillution of precision.
+ * @QMI_PDS_DATA_VALID_OPERATING_MODE: Operating mode.
+ *
+ * Flags to indicate which position data parameters are valid.
+ */
+typedef enum {
+    QMI_PDS_DATA_VALID_TIMESTAMP_CALENDAR      = 1 << 0,
+    QMI_PDS_DATA_VALID_TIMESTAMP_UTC           = 1 << 1,
+    QMI_PDS_DATA_VALID_LEAP_SECONDS            = 1 << 2,
+    QMI_PDS_DATA_VALID_TIME_UNCERTAINTY        = 1 << 3,
+    QMI_PDS_DATA_VALID_LATITUDE                = 1 << 4,
+    QMI_PDS_DATA_VALID_LONGITUDE               = 1 << 5,
+    QMI_PDS_DATA_VALID_ELLIPSOID_ALTITUDE      = 1 << 6,
+    QMI_PDS_DATA_VALID_MEAN_SEA_LEVEL_ALTITUDE = 1 << 7,
+    QMI_PDS_DATA_VALID_HORIZONTAL_SPEED        = 1 << 8,
+    QMI_PDS_DATA_VALID_VERTICAL_SPEED          = 1 << 9,
+    QMI_PDS_DATA_VALID_HEADING                 = 1 << 10,
+    QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_CIRCULAR               = 1 << 11,
+    QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MAJOR     = 1 << 12,
+    QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_SEMI_MINOR     = 1 << 13,
+    QMI_PDS_DATA_VALID_HORIZONTAL_UNCERTAINTY_ELLIPSE_ORIENT_AZIMUTH = 1 << 14,
+    QMI_PDS_DATA_VALID_VERTICAL_UNCERTAINTY                          = 1 << 15,
+    QMI_PDS_DATA_VALID_HORIZONTAL_VELOCITY_UNCERTAINTY               = 1 << 16,
+    QMI_PDS_DATA_VALID_VERTICAL_VELOCITY_UNCERTAINTY                 = 1 << 17,
+    QMI_PDS_DATA_VALID_HORIZONTAL_CONFIDENCE   = 1 << 18,
+    QMI_PDS_DATA_VALID_POSITION_DOP            = 1 << 19,
+    QMI_PDS_DATA_VALID_HORIZONTAL_DOP          = 1 << 20,
+    QMI_PDS_DATA_VALID_VERTICAL_DOP            = 1 << 21,
+    QMI_PDS_DATA_VALID_OPERATING_MODE          = 1 << 22
+} QmiPdsDataValid;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI PDS Get GPS Service State' request/response */
+
+/**
+ * QmiPdsTrackingSessionState:
+ * @QMI_PDS_TRACKING_SESSION_STATE_UNKNOWN: Unknown state.
+ * @QMI_PDS_TRACKING_SESSION_STATE_INACTIVE: Session inactive.
+ * @QMI_PDS_TRACKING_SESSION_STATE_ACTIVE: Session active.
+ *
+ * State of the tracking session.
+ */
+typedef enum {
+    QMI_PDS_TRACKING_SESSION_STATE_UNKNOWN  = 0,
+    QMI_PDS_TRACKING_SESSION_STATE_INACTIVE = 1,
+    QMI_PDS_TRACKING_SESSION_STATE_ACTIVE   = 2
+} QmiPdsTrackingSessionState;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_PDS_H_ */
diff --git a/src/libqmi-glib/qmi-enums-private.h b/src/libqmi-glib/qmi-enums-private.h
new file mode 100644
index 0000000..21afead
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-private.h
@@ -0,0 +1,85 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_PRIVATE_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_PRIVATE_H_
+
+/*****************************************************************************/
+/* QMI Control */
+
+/**
+ * QmiCtlDataFormat:
+ * @QMI_CTL_DATA_FORMAT_QOS_FLOW_HEADER_ABSENT: QoS header absent
+ * @QMI_CTL_DATA_FORMAT_QOS_FLOW_HEADER_PRESENT: QoS header present
+ *
+ * Controls whether the network port data format includes a QoS header or not.
+ * Should normally be set to ABSENT.
+ */
+typedef enum {
+    QMI_CTL_DATA_FORMAT_QOS_FLOW_HEADER_ABSENT  = 0,
+    QMI_CTL_DATA_FORMAT_QOS_FLOW_HEADER_PRESENT = 1,
+} QmiCtlDataFormat;
+
+/**
+ * QmiCtlDataLinkProtocol:
+ * @QMI_CTL_DATA_LINK_PROTOCOL_802_3: data frames formatted as 802.3 Ethernet
+ * @QMI_CTL_DATA_LINK_PROTOCOL_RAW_IP: data frames are raw IP packets
+ *
+ * Determines the network port data format.
+ */
+typedef enum {
+    QMI_CTL_DATA_LINK_PROTOCOL_UNKNOWN = 0,
+    QMI_CTL_DATA_LINK_PROTOCOL_802_3   = 1,
+    QMI_CTL_DATA_LINK_PROTOCOL_RAW_IP  = 2,
+} QmiCtlDataLinkProtocol;
+
+/**
+ * QmiCtlFlag:
+ * @QMI_CTL_FLAG_NONE: None.
+ * @QMI_CTL_FLAG_RESPONSE: Message is a response.
+ * @QMI_CTL_FLAG_INDICATION: Message is an indication.
+ *
+ * QMI flags in messages of the %QMI_SERVICE_CTL service.
+ */
+typedef enum {
+    QMI_CTL_FLAG_NONE       = 0,
+    QMI_CTL_FLAG_RESPONSE   = 1 << 0,
+    QMI_CTL_FLAG_INDICATION = 1 << 1
+} QmiCtlFlag;
+
+/**
+ * QmiServiceFlag:
+ * @QMI_SERVICE_FLAG_NONE: None.
+ * @QMI_SERVICE_FLAG_COMPOUND: Message is compound.
+ * @QMI_SERVICE_FLAG_RESPONSE: Message is a response.
+ * @QMI_SERVICE_FLAG_INDICATION: Message is an indication.
+ *
+ * QMI flags in messages which are not of the %QMI_SERVICE_CTL service.
+ */
+typedef enum {
+    QMI_SERVICE_FLAG_NONE       = 0,
+    QMI_SERVICE_FLAG_COMPOUND   = 1 << 0,
+    QMI_SERVICE_FLAG_RESPONSE   = 1 << 1,
+    QMI_SERVICE_FLAG_INDICATION = 1 << 2
+} QmiServiceFlag;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_PRIVATE_H_ */
diff --git a/src/libqmi-glib/qmi-enums-uim.h b/src/libqmi-glib/qmi-enums-uim.h
new file mode 100644
index 0000000..ec89d31
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-uim.h
@@ -0,0 +1,124 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_UIM_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_UIM_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-uim
+ * @title: UIM enumerations and flags
+ *
+ * This section defines enumerations and flags used in the UIM service
+ * interface.
+ */
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI UIM Read Record' request/response */
+
+/**
+ * QmiUimSessionType:
+ * @QMI_UIM_SESSION_TYPE_PRIMARY_GW_PROVISIONING: Primary GSM/WCDMA provisioning.
+ * @QMI_UIM_SESSION_TYPE_PRIMARY_1X_PROVISIONING: Primary CDMA1x provisioning.
+ * @QMI_UIM_SESSION_TYPE_SECONDARY_GW_PROVISIONING: Secondary GSM/WCDMA provisioning.
+ * @QMI_UIM_SESSION_TYPE_SECONDARY_1X_PROVISIONING: Secondary CDMA1x provisioning.
+ * @QMI_UIM_SESSION_TYPE_NONPROVISIONING_SLOT_1: Nonprovisioning on slot 1.
+ * @QMI_UIM_SESSION_TYPE_NONPROVISIONING_SLOT_2: Nonprovisioning on slot 2.
+ * @QMI_UIM_SESSION_TYPE_CARD_SLOT_1: Card on slot 1.
+ * @QMI_UIM_SESSION_TYPE_CARD_SLOT_2: Card on slot 2.
+ * @QMI_UIM_SESSION_TYPE_LOGICAL_CHANNEL_SLOT_1: Logical channel on slot 1.
+ * @QMI_UIM_SESSION_TYPE_LOGICAL_CHANNEL_SLOT_2: Logical channel on slot 2.
+ *
+ * Type of UIM session.
+ */
+typedef enum {
+    QMI_UIM_SESSION_TYPE_PRIMARY_GW_PROVISIONING   = 0,
+    QMI_UIM_SESSION_TYPE_PRIMARY_1X_PROVISIONING   = 1,
+    QMI_UIM_SESSION_TYPE_SECONDARY_GW_PROVISIONING = 2,
+    QMI_UIM_SESSION_TYPE_SECONDARY_1X_PROVISIONING = 3,
+    QMI_UIM_SESSION_TYPE_NONPROVISIONING_SLOT_1    = 4,
+    QMI_UIM_SESSION_TYPE_NONPROVISIONING_SLOT_2    = 5,
+    QMI_UIM_SESSION_TYPE_CARD_SLOT_1               = 6,
+    QMI_UIM_SESSION_TYPE_CARD_SLOT_2               = 7,
+    QMI_UIM_SESSION_TYPE_LOGICAL_CHANNEL_SLOT_1    = 8,
+    QMI_UIM_SESSION_TYPE_LOGICAL_CHANNEL_SLOT_2    = 9
+} QmiUimSessionType;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI UIM Get File Attributes' request/response */
+
+/**
+ * QmiUimFileType:
+ * @QMI_UIM_FILE_TYPE_TRANSPARENT: Transparent.
+ * @QMI_UIM_FILE_TYPE_CYCLIC: Cyclic.
+ * @QMI_UIM_FILE_TYPE_LINEAR_FIXED: Linear fixed.
+ * @QMI_UIM_FILE_TYPE_DEDICATED_FILE: Dedicated file.
+ * @QMI_UIM_FILE_TYPE_MASTER_FILE: Master file.
+ *
+ * Type of UIM file.
+ */
+typedef enum {
+    QMI_UIM_FILE_TYPE_TRANSPARENT    = 0,
+    QMI_UIM_FILE_TYPE_CYCLIC         = 1,
+    QMI_UIM_FILE_TYPE_LINEAR_FIXED   = 2,
+    QMI_UIM_FILE_TYPE_DEDICATED_FILE = 3,
+    QMI_UIM_FILE_TYPE_MASTER_FILE    = 4
+} QmiUimFileType;
+
+/**
+ * QmiUimSecurityAttributeLogic:
+ * @QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_ALWAYS: Always.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_NEVER: Never.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_AND: And.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_OR: Or.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_SINGLE: Single.
+ *
+ * Logic applicable to security attributes.
+ */
+typedef enum {
+    QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_ALWAYS = 0,
+    QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_NEVER  = 1,
+    QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_AND    = 2,
+    QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_OR     = 3,
+    QMI_UIM_SECURITY_ATTRIBUTE_LOGIC_SINGLE = 4
+} QmiUimSecurityAttributeLogic;
+
+/**
+ * QmiUimSecurityAttribute:
+ * @QMI_UIM_SECURITY_ATTRIBUTE_PIN1: PIN1.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_PIN2: PIN2.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_UPIN: UPIN.
+ * @QMI_UIM_SECURITY_ATTRIBUTE_ADM: ADM.
+ *
+ * Security Attributes.
+ */
+typedef enum {
+    QMI_UIM_SECURITY_ATTRIBUTE_PIN1 = 1 << 0,
+    QMI_UIM_SECURITY_ATTRIBUTE_PIN2 = 1 << 1,
+    QMI_UIM_SECURITY_ATTRIBUTE_UPIN = 1 << 2,
+    QMI_UIM_SECURITY_ATTRIBUTE_ADM  = 1 << 3
+} QmiUimSecurityAttribute;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_UIM_H_ */
diff --git a/src/libqmi-glib/qmi-enums-wds.c b/src/libqmi-glib/qmi-enums-wds.c
new file mode 100644
index 0000000..8539271
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-wds.c
@@ -0,0 +1,53 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "qmi-enums-wds.h"
+#include "qmi-enum-types.h"
+
+const gchar *
+qmi_wds_verbose_call_end_reason_get_string (QmiWdsVerboseCallEndReasonType type,
+                                            gint16 reason)
+{
+    switch (type) {
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_MIP:
+        return qmi_wds_verbose_call_end_reason_mip_get_string ((QmiWdsVerboseCallEndReasonMip)reason);
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_INTERNAL:
+        return qmi_wds_verbose_call_end_reason_internal_get_string ((QmiWdsVerboseCallEndReasonInternal)reason);
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_CM:
+        return qmi_wds_verbose_call_end_reason_cm_get_string ((QmiWdsVerboseCallEndReasonCm)reason);
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_3GPP:
+        return qmi_wds_verbose_call_end_reason_3gpp_get_string ((QmiWdsVerboseCallEndReason3gpp)reason);
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_PPP:
+        return qmi_wds_verbose_call_end_reason_ppp_get_string ((QmiWdsVerboseCallEndReasonPpp)reason);
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_EHRPD:
+        return qmi_wds_verbose_call_end_reason_ehrpd_get_string ((QmiWdsVerboseCallEndReasonEhrpd)reason);
+    case QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_IPV6:
+        return qmi_wds_verbose_call_end_reason_ipv6_get_string ((QmiWdsVerboseCallEndReasonIpv6)reason);
+    default:
+        return NULL;
+    }
+}
diff --git a/src/libqmi-glib/qmi-enums-wds.h b/src/libqmi-glib/qmi-enums-wds.h
new file mode 100644
index 0000000..2bfc624
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-wds.h
@@ -0,0 +1,971 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Lanedo GmbH <aleksander@lanedo.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_WDS_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_WDS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-wds
+ * @title: WDS enumerations and flags
+ *
+ * This section defines enumerations and flags used in the WDS service
+ * interface.
+ */
+
+#include <glib.h>
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WDS Start Network' message */
+
+/**
+ * QmiWdsIpFamily:
+ * @QMI_WDS_IP_FAMILY_IPV4: IPv4.
+ * @QMI_WDS_IP_FAMILY_IPV6: IPv6.
+ * @QMI_WDS_IP_FAMILY_UNSPECIFIED: None specified.
+ *
+ * Type of IP family preference.
+ */
+typedef enum {
+    QMI_WDS_IP_FAMILY_IPV4        = 4,
+    QMI_WDS_IP_FAMILY_IPV6        = 6,
+    QMI_WDS_IP_FAMILY_UNSPECIFIED = 8
+} QmiWdsIpFamily;
+
+/**
+ * QmiWdsTechnologyPreference:
+ * @QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP: 3GPP allowed.
+ * @QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP2: 3GPP2 allowed.
+ *
+ * Type of network allowed when trying to connect.
+ */
+typedef enum {
+    QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP  = 1 << 0,
+    QMI_WDS_TECHNOLOGY_PREFERENCE_ALLOW_3GPP2 = 1 << 1
+} QmiWdsTechnologyPreference;
+
+/**
+ * QmiWdsExtendedTechnologyPreference:
+ * @QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_CDMA: Use CDMA.
+ * @QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_UMTS: Use UMTS.
+ * @QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_EPC: Use EPC (LTE).
+ * @QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_EMBMS: Use eMBMS.
+ * @QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_MODEM_LINK_LOCAL: Use modem link-local.
+ *
+ * Type of network allowed when trying to connect.
+ */
+typedef enum {
+    QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_CDMA             = 32769,
+    QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_UMTS             = 32772,
+    QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_EPC              = 34944,
+    QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_EMBMS            = 34946,
+    QMI_WDS_EXTENDED_TECHNOLOGY_PREFERENCE_MODEM_LINK_LOCAL = 34952,
+} QmiWdsExtendedTechnologyPreference;
+
+/**
+ * QmiWdsCallType:
+ * @QMI_WDS_CALL_TYPE_LAPTOP: Laptop call.
+ * @QMI_WDS_CALL_TYPE_EMBEDDED: Embedded call.
+ *
+ * Type of call to originate.
+ */
+typedef enum {
+    QMI_WDS_CALL_TYPE_LAPTOP   = 0,
+    QMI_WDS_CALL_TYPE_EMBEDDED = 1
+} QmiWdsCallType;
+
+/**
+ * QmiWdsCallEndReason:
+ * @QMI_WDS_CALL_END_REASON_GENERIC_UNSPECIFIED: Unspecified reason.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_CLIENT_END: Client end.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_NO_SERVICE: No service.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_FADE: Fade.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_RELEASE_NORMAL: Release normal.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_ACCESS_ATTEMPT_IN_PROGRESS: Access attempt in progress.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_ACCESS_FAILURE: Access Failure.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_REDIRECTION_OR_HANDOFF: Redirection or handoff.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_CLOSE_IN_PROGRESS: Close in progress.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_AUTHENTICATION_FAILED: Authentication failed.
+ * @QMI_WDS_CALL_END_REASON_GENERIC_INTERNAL_ERROR: Internal error.
+ * @QMI_WDS_CALL_END_REASON_CDMA_LOCK: (CDMA) Phone is CDMA-locked.
+ * @QMI_WDS_CALL_END_REASON_CDMA_INTERCEPT: (CDMA) Received intercept from the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_REORDER: (CDMA) Received reorder from the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_RELEASE_SO_REJECT: (CDMA) Received release from the BS, SO reject.
+ * @QMI_WDS_CALL_END_REASON_CDMA_INCOMING_CALL: (CDMA) Received incoming call from the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_ALERT_STOP: (CDMA) Received alert stop from the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_ACTIVATION: (CDMA) Received end activation.
+ * @QMI_WDS_CALL_END_REASON_CDMA_MAX_ACCESS_PROBES: (CDMA) Maximum access probes transmitted.
+ * @QMI_WDS_CALL_END_REASON_CDMA_CCS_NOT_SUPPORTED_BY_BS: (CDMA) Concurrent service not supported by the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_NO_RESPONSE_FROM_BS: (CDMA) No response received from the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_REJECTED_BY_BS: (CDMA) Rejected by the BS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_INCOMPATIBLE: (CDMA) Concurrent services requested are incompatible.
+ * @QMI_WDS_CALL_END_REASON_CDMA_ALREADY_IN_TC: (CDMA) Already in TC.
+ * @QMI_WDS_CALL_END_REASON_CDMA_USER_CALL_ORIGINATED_DURING_GPS: (CDMA) Call originated during GPS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_USER_CALL_ORIGINATED_DURING_SMS: (CDMA) Call originated during SMS.
+ * @QMI_WDS_CALL_END_REASON_CDMA_NO_SERVICE: (CDMA) No service.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_CONFERENCE_FAILED: (GSM/WCDMA) Call origination request failed.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_INCOMING_REJECTED: (GSM/WCDMA) Client rejected incoming call.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_NO_SERVICE: (GSM/WCDMA) No service.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_NETWORK_END: (GSM/WCDMA) Network ended the call.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_LLC_SNDCP_FAILURE: (GSM/WCDMA) LLC or SNDCP failure.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_INSUFFICIENT_RESOURCES: (GSM/WCDMA) Insufficient resources.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPTION_TEMPORARILY_OUT_OF_ORDER: (GSM/WCDMA) Service option temporarily out of order.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_NSAPI_ALREADY_USED: (GSM/WCDMA) NSAPI already used.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_REGULAR_DEACTIVATION: (GSM/WCDMA) Regular PDP context deactivation.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_NETWORK_FAILURE: (GSM/WCDMA) Network failure.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_REATTACH_REQUIRED: (GSM/WCDMA) Reattach required.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_PROTOCOL_ERROR: (GSM/WCDMA) Protocol error.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPERATOR_DETERMINED_BARRING: (GSM/WCDMA) Operator-determined barring.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_APN: (GSM/WCDMA) Unknown or missing APN.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_PDP: (GSM/WCDMA) Unknown PDP address or type.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_GGSN_REJECT: (GSM/WCDMA) Activation rejected by GGSN.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_ACTIVATION_REJECT: (GSM/WCDMA) Activation rejected.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPTION_NOT_SUPPORTED: (GSM/WCDMA) Service option not supported.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPTION_UNSUBSCRIBED: (GSM/WCDMA) Service option not subscribed.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_QOS_NOT_ACCEPTED: (GSM/WCDMA) QoS not accepted.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_TFT_SEMANTIC_ERROR: (GSM/WCDMA) Semantic error in TFT operation.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_TFT_SYNTAX_ERROR: (GSM/WCDMA) Syntax error in TFT operation.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_PDP_CONTEXT: (GSM/WCDMA) Unknown PDP context.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_FILTER_SEMANTIC_ERROR: (GSM/WCDMA) Semantic error in packet filters.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_FILTER_SYNTAX_ERROR: (GSM/WCDMA) Syntax error in packet filters.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_PDP_WITHOUT_ACTIVE_TFT: (GSM/WCDMA) PDP context without TFT activated.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_INVALID_TRANSACTION_ID: (GSM/WCDMA) Invalid transaction ID.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_INCORRECT_SEMANTIC: (GSM/WCDMA) Message incorrect semantically.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_INVALID_MANDATORY_INFO: (GSM/WCDMA) Invalid mandatory information.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_TYPE_UNSUPPORTED: (GSM/WCDMA) Message type not implemented.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_TYPE_NONCOMPATIBLE_STATE: (GSM/WCDMA) Message not compatible with state.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_INFO_ELEMENT: (GSM/WCDMA) Information element unknown.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_CONDITIONAL_IE_ERROR: (GSM/WCDMA) Conditional IE error.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_AND_PROTOCOL_STATE_UNCOMPATIBLE: (GSM/WCDMA) Message and protocol state uncompatible.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_APN_TYPE_CONFLICT: (GSM/WCDMA) APN type conflict.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_NO_GPRS_CONTEXT: (GSM/WCDMA) No GPRS context.
+ * @QMI_WDS_CALL_END_REASON_GSM_WCDMA_FEATURE_NOT_SUPPORTED: (GSM/WCDMA) Feature not supported.
+ * @QMI_WDS_CALL_END_REASON_EVDO_CONNECTION_DENY_GENERAL_OR_BUSY: (EV-DO) Received Connection Deny (General or Network busy).
+ * @QMI_WDS_CALL_END_REASON_EVDO_CONNECTION_DENY_BILLING_OR_AUTHENTICATION_FAILURE: (EV-DO) Received Connection Deny (Billing or Authentication failure).
+ * @QMI_WDS_CALL_END_REASON_EVDO_HDR_CHANGE: (EV-DO) Change HDR.
+ * @QMI_WDS_CALL_END_REASON_EVDO_HDR_EXIT: (EV-DO) Exit HDR.
+ * @QMI_WDS_CALL_END_REASON_EVDO_HDR_NO_SESSION: (EV-DO) No HDR session.
+ * @QMI_WDS_CALL_END_REASON_EVDO_HDR_ORIGINATION_DURING_GPS_FIX: (EV-DO) HDR call ended in favor of a GPS fix.
+ * @QMI_WDS_CALL_END_REASON_EVDO_HDR_CONNECTION_SETUP_TIMEOUT: (EV-DO) Connection setup timeout.
+ * @QMI_WDS_CALL_END_REASON_EVDO_HDR_RELEASED_BY_CM: (EV-DO) Released HDR call by call manager.
+ *
+ * Reason for ending the call.
+ */
+typedef enum {
+    /* Generic reasons */
+    QMI_WDS_CALL_END_REASON_GENERIC_UNSPECIFIED                = 1,
+    QMI_WDS_CALL_END_REASON_GENERIC_CLIENT_END                 = 2,
+    QMI_WDS_CALL_END_REASON_GENERIC_NO_SERVICE                 = 3,
+    QMI_WDS_CALL_END_REASON_GENERIC_FADE                       = 4,
+    QMI_WDS_CALL_END_REASON_GENERIC_RELEASE_NORMAL             = 5,
+    QMI_WDS_CALL_END_REASON_GENERIC_ACCESS_ATTEMPT_IN_PROGRESS = 6,
+    QMI_WDS_CALL_END_REASON_GENERIC_ACCESS_FAILURE             = 7,
+    QMI_WDS_CALL_END_REASON_GENERIC_REDIRECTION_OR_HANDOFF     = 8,
+    QMI_WDS_CALL_END_REASON_GENERIC_CLOSE_IN_PROGRESS          = 9,
+    QMI_WDS_CALL_END_REASON_GENERIC_AUTHENTICATION_FAILED      = 10,
+    QMI_WDS_CALL_END_REASON_GENERIC_INTERNAL_ERROR             = 11,
+
+    /* CDMA specific reasons */
+    QMI_WDS_CALL_END_REASON_CDMA_LOCK                            = 500,
+    QMI_WDS_CALL_END_REASON_CDMA_INTERCEPT                       = 501,
+    QMI_WDS_CALL_END_REASON_CDMA_REORDER                         = 502,
+    QMI_WDS_CALL_END_REASON_CDMA_RELEASE_SO_REJECT               = 503,
+    QMI_WDS_CALL_END_REASON_CDMA_INCOMING_CALL                   = 504,
+    QMI_WDS_CALL_END_REASON_CDMA_ALERT_STOP                      = 505,
+    QMI_WDS_CALL_END_REASON_CDMA_ACTIVATION                      = 506,
+    QMI_WDS_CALL_END_REASON_CDMA_MAX_ACCESS_PROBES               = 507,
+    QMI_WDS_CALL_END_REASON_CDMA_CCS_NOT_SUPPORTED_BY_BS         = 508,
+    QMI_WDS_CALL_END_REASON_CDMA_NO_RESPONSE_FROM_BS             = 509,
+    QMI_WDS_CALL_END_REASON_CDMA_REJECTED_BY_BS                  = 510,
+    QMI_WDS_CALL_END_REASON_CDMA_INCOMPATIBLE                    = 511,
+    QMI_WDS_CALL_END_REASON_CDMA_ALREADY_IN_TC                   = 512,
+    QMI_WDS_CALL_END_REASON_CDMA_USER_CALL_ORIGINATED_DURING_GPS = 513,
+    QMI_WDS_CALL_END_REASON_CDMA_USER_CALL_ORIGINATED_DURING_SMS = 514,
+    QMI_WDS_CALL_END_REASON_CDMA_NO_SERVICE                      = 515,
+
+    /* GSM/WCDMA specific reasons */
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_CONFERENCE_FAILED                       = 1000,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_INCOMING_REJECTED                       = 1001,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_NO_SERVICE                              = 1002,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_NETWORK_END                             = 1003,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_LLC_SNDCP_FAILURE                       = 1004,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_INSUFFICIENT_RESOURCES                  = 1005,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPTION_TEMPORARILY_OUT_OF_ORDER         = 1006,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_NSAPI_ALREADY_USED                      = 1007,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_REGULAR_DEACTIVATION                    = 1008,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_NETWORK_FAILURE                         = 1009,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_REATTACH_REQUIRED                       = 1010,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_PROTOCOL_ERROR                          = 1011,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPERATOR_DETERMINED_BARRING             = 1012,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_APN                             = 1013,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_PDP                             = 1014,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_GGSN_REJECT                             = 1015,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_ACTIVATION_REJECT                       = 1016,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPTION_NOT_SUPPORTED                    = 1017,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_OPTION_UNSUBSCRIBED                     = 1018,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_QOS_NOT_ACCEPTED                        = 1019,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_TFT_SEMANTIC_ERROR                      = 1020,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_TFT_SYNTAX_ERROR                        = 1021,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_PDP_CONTEXT                     = 1022,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_FILTER_SEMANTIC_ERROR                   = 1023,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_FILTER_SYNTAX_ERROR                     = 1024,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_PDP_WITHOUT_ACTIVE_TFT                  = 1025,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_INVALID_TRANSACTION_ID                  = 1026,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_INCORRECT_SEMANTIC              = 1027,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_INVALID_MANDATORY_INFO                  = 1028,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_TYPE_UNSUPPORTED                = 1029,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_TYPE_NONCOMPATIBLE_STATE        = 1030,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_UNKNOWN_INFO_ELEMENT                    = 1031,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_CONDITIONAL_IE_ERROR                    = 1032,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_MESSAGE_AND_PROTOCOL_STATE_UNCOMPATIBLE = 1033,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_APN_TYPE_CONFLICT                       = 1034,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_NO_GPRS_CONTEXT                         = 1035,
+    QMI_WDS_CALL_END_REASON_GSM_WCDMA_FEATURE_NOT_SUPPORTED                   = 1036,
+
+    /* EV-DO specific reasons */
+    QMI_WDS_CALL_END_REASON_EVDO_CONNECTION_DENY_GENERAL_OR_BUSY                   = 1500,
+    QMI_WDS_CALL_END_REASON_EVDO_CONNECTION_DENY_BILLING_OR_AUTHENTICATION_FAILURE = 1501,
+    QMI_WDS_CALL_END_REASON_EVDO_HDR_CHANGE                                        = 1502,
+    QMI_WDS_CALL_END_REASON_EVDO_HDR_EXIT                                          = 1503,
+    QMI_WDS_CALL_END_REASON_EVDO_HDR_NO_SESSION                                    = 1504,
+    QMI_WDS_CALL_END_REASON_EVDO_HDR_ORIGINATION_DURING_GPS_FIX                    = 1505,
+    QMI_WDS_CALL_END_REASON_EVDO_HDR_CONNECTION_SETUP_TIMEOUT                      = 1506,
+    QMI_WDS_CALL_END_REASON_EVDO_HDR_RELEASED_BY_CM                                = 1507
+} QmiWdsCallEndReason;
+
+/**
+ * QmiWdsVerboseCallEndReasonType:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_MIP: Mobile IP.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_INTERNAL: Internal.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_CM: Call manager.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_3GPP: 3GPP.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_PPP: PPP.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_EHRPD: eHRPD.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_IPV6: IPv6.
+    *
+ * Type of verbose call end reason.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_MIP      = 1,
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_INTERNAL = 2,
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_CM       = 3,
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_3GPP     = 6,
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_PPP      = 7,
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_EHRPD    = 8,
+    QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_IPV6     = 9
+} QmiWdsVerboseCallEndReasonType;
+
+const gchar *qmi_wds_verbose_call_end_reason_get_string (QmiWdsVerboseCallEndReasonType type,
+                                                         gint16 reason);
+
+/**
+ * QmiWdsVerboseCallEndReasonMip:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_ERROR_REASON_UNKNOWN: Unknown reason.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REASON_UNSPECIFIED: (FA error) Reason unspecified.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_ADMINISTRATIVELY_PROHIBITED: (FA error) Administratively prohibited.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_INSUFFICIENT_RESOURCES: (FA error) Insufficient resources.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MOBILE_NODE_AUTHENTICATION_FAILURE: (FA error) Mobile node authenticatin failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_HA_AUTHENTICATION_FAILURE: (FA error) HA authentication failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REQUESTED_LIFETIME_TOO_LONG: (FA error) Requested lifetime too long.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MALFORMED_REQUEST: (FA error) Malformed request.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MALFORMED_REPLY: (FA error) Malformed reply.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_ENCAPSULATION_UNAVAILABLE: (FA error) Encapsulation unavailable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_VJHC_UNAVAILABLE: (FA error) VJHC unavailable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REVERSE_TUNNEL_UNAVAILABLE: (FA error) Reverse tunnel unavailable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REVERSE_TUNNEL_MANDATORY_AND_T_BIT_NOT_SET: (FA error) Reverse tunnel mandatory and T bit not set.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_DELIVERY_STYLE_NOT_SUPPORTED: (FA error) Delivery style not supported.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_NAI: (FA error) Missing NAI.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_HA: (FA error) Missing HA.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_HOME_ADDRESS: (FA error) Missing home address.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_UNKNOWN_CHALLENGE: (FA error) Unknown challenge.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_CHALLENGE: (FA error) Missing challenge.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_STALE_CHALLENGE: (FA error) Stale challenge.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REASON_UNSPECIFIED: (HA error) Reason unspecified.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_ADMINISTRATIVELY_PROHIBITED: (HA error) Administratively prohibited.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_INSUFFICIENT_RESOURCES: (HA error) Insufficient resources.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_MOBILE_NODE_AUTHENTICATION_FAILURE: (HA error) Mobile node authentication failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_FA_AUTHENTICATION_FAILURE: (HA error) FA authentication failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REGISTRATION_ID_MISMATCH: (HA error) Registration ID mismatch.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_MALFORMED_REQUEST: (HA error) Malformed request.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_UNKNOWN_HA_ADDRESS: (HA error) Unknown HA address.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REVERSE_TUNNEL_UNAVAILABLE: (HA error) Reverse tunnel unavailable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REVERSE_TUNNEL_MANDATORY_AND_T_BIT_NOT_SET: (HA error) Reverse tunnel mandatory and T bit not set.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_ENCAPSULATION_UNAVAILABLE: (HA error) Encapsulation unavailable.
+ *
+ * Mobile IP specific call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_MIP.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_ERROR_REASON_UNKNOWN                                = -1,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REASON_UNSPECIFIED                         = 64,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_ADMINISTRATIVELY_PROHIBITED                = 65,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_INSUFFICIENT_RESOURCES                     = 66,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MOBILE_NODE_AUTHENTICATION_FAILURE         = 67,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_HA_AUTHENTICATION_FAILURE                  = 68,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REQUESTED_LIFETIME_TOO_LONG                = 69,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MALFORMED_REQUEST                          = 70,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MALFORMED_REPLY                            = 71,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_ENCAPSULATION_UNAVAILABLE                  = 72,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_VJHC_UNAVAILABLE                           = 73,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REVERSE_TUNNEL_UNAVAILABLE                 = 74,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_REVERSE_TUNNEL_MANDATORY_AND_T_BIT_NOT_SET = 75,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_DELIVERY_STYLE_NOT_SUPPORTED               = 79,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_NAI                                = 97,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_HA                                 = 98,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_HOME_ADDRESS                       = 99,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_UNKNOWN_CHALLENGE                          = 104,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_MISSING_CHALLENGE                          = 105,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_FA_ERROR_STALE_CHALLENGE                            = 106,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REASON_UNSPECIFIED                         = 128,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_ADMINISTRATIVELY_PROHIBITED                = 129,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_INSUFFICIENT_RESOURCES                     = 130,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_MOBILE_NODE_AUTHENTICATION_FAILURE         = 131,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_FA_AUTHENTICATION_FAILURE                  = 132,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REGISTRATION_ID_MISMATCH                   = 133,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_MALFORMED_REQUEST                          = 134,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_UNKNOWN_HA_ADDRESS                         = 136,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REVERSE_TUNNEL_UNAVAILABLE                 = 137,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_REVERSE_TUNNEL_MANDATORY_AND_T_BIT_NOT_SET = 138,
+    QMI_WDS_VERBOSE_CALL_END_REASON_MIP_HA_ERROR_ENCAPSULATION_UNAVAILABLE                  = 139
+} QmiWdsVerboseCallEndReasonMip;
+
+/**
+ * QmiWdsVerboseCallEndReasonInternal:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_ERROR: Internal error.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_CALL_ENDED: Call ended.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_UNKNOWN_INTERNAL_CAUSE: Unknown internal cause.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_UNKNOWN_CAUSE: Unknown cause.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_CLOSE_IN_PROGRESS: Close in progress.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_NETWORK_INITIATED_TERMINATION: Network initiated termination.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_APP_PREEMPTED: App preempted.
+ *
+ * Internal call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_INTERNAL.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_ERROR                         = 201,
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_CALL_ENDED                    = 202,
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_UNKNOWN_INTERNAL_CAUSE        = 203,
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_UNKNOWN_CAUSE                 = 204,
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_CLOSE_IN_PROGRESS             = 205,
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_NETWORK_INITIATED_TERMINATION = 206,
+    QMI_WDS_VERBOSE_CALL_END_REASON_INTERNAL_APP_PREEMPTED                 = 207
+} QmiWdsVerboseCallEndReasonInternal;
+
+/**
+ * QmiWdsVerboseCallEndReasonCm:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CDMA_LOCK: (CDMA) Phone is CDMA-locked.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_INTERCEPT: (CDMA) Received intercept from the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_REORDER: (CDMA) Received reorder from the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_RELEASE_SO_REJECT: (CDMA) Received release from the BS, SO reject.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_INCOMING_CALL: (CDMA) Received incoming call from the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ALERT_STOP: (CDMA) Received alert stop from the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACTIVATION: (CDMA) Received end activation.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_MAX_ACCESS_PROBES: (CDMA) Maximum access probes transmitted.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CCS_NOT_SUPPORTED_BY_BS: (CDMA) Concurrent service not supported by the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_RESPONSE_FROM_BS: (CDMA) No response received from the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_REJECTED_BY_BS: (CDMA) Rejected by the BS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_INCOMPATIBLE: (CDMA) Concurrent services requested are incompatible.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ALREADY_IN_TC: (CDMA) Already in TC.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_USER_CALL_ORIGINATED_DURING_GPS: (CDMA) Call originated during GPS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_USER_CALL_ORIGINATED_DURING_SMS: (CDMA) Call originated during SMS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_CDMA_SERVICE: (CDMA) No service.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_RETRY_ORDER: Retry order.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONFIGURATION_FAILED: Configuration failed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_INCOMING_REJECTED: Incoming rejected.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_GATEWAY_SERVICE: No gateway service.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_GPRS_CONTEXT: No GPRS context.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ILLEGAL_MS: Illegal MS.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ILLEGAL_ME: Illegal ME.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_GPRS_AND_NON_GPRS_SERVICES_NOT_ALLOWED: GPRS and non GPRS services not allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_GPRS_SERVICES_NOT_ALLOWED: GPRS services not allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_MS_IDENTITY_NOT_DERIVED_BY_THE_NETWORK: MS identity not derived by the network.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_IMPLICITLY_DETACHED: Implicitly detached.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_PLMN_NOT_ALLOWED: PLMN not allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_LA_NOT_ALLOWED: LA not allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_GPRS_SERVICES_NOT_ALLOWED_IN_PLMN: GPRS services not allowed in PLMN.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_PDP_DUPLICATE: PDP duplicate.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_UE_RAT_CHANGE: UE radio access technology change.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONGESTION: Congestion.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_PDP_CONTEXT_ACTIVATED: No PDP context activated.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACCESS_CLASS_DSAC_REJECTION: Access class DSAC rejection.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONNECTION_DENY_GENERAL_OR_BUSY: (EV-DO) Received Connection Deny (General or Network busy).
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONNECTION_DENY_BILLING_OR_AUTHENTICATION_FAILURE: (EV-DO) Received Connection Deny (Billing or Authentication failure).
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_CHANGE: (EV-DO) Change HDR.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_EXIT: (EV-DO) Exit HDR.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_NO_SESSION: (EV-DO) No HDR session.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_ORIGINATION_DURING_GPS_FIX: (EV-DO) HDR call ended in favor of a GPS fix.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_CONNECTION_SETUP_TIMEOUT: (EV-DO) Connection setup timeout.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_RELEASED_BY_CM: (EV-DO) Released HDR call by call manager.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_HYBRID_HDR_SERVICE: (EV-DO) No hybrid HDR service.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_CLIENT_END: Client end.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_SERVICE: No service.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_FADE: Fade.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_RELEASE_NORMAL: Release normal.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACCESS_ATTEMPT_IN_PROGRESS: Access attempt in progress.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACCESS_FAILURE: Access Failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_CM_REDIRECTION_OR_HANDOFF: Redirection or handoff.
+ *
+ * Call manager specific call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_CM.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CDMA_LOCK                       = 500,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_INTERCEPT                       = 501,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_REORDER                         = 502,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_RELEASE_SO_REJECT               = 503,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_INCOMING_CALL                   = 504,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ALERT_STOP                      = 505,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACTIVATION                      = 506,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_MAX_ACCESS_PROBES               = 507,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CCS_NOT_SUPPORTED_BY_BS         = 508,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_RESPONSE_FROM_BS             = 509,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_REJECTED_BY_BS                  = 510,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_INCOMPATIBLE                    = 511,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ALREADY_IN_TC                   = 512,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_USER_CALL_ORIGINATED_DURING_GPS = 513,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_USER_CALL_ORIGINATED_DURING_SMS = 514,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_CDMA_SERVICE                 = 515,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_RETRY_ORDER                     = 519,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONFIGURATION_FAILED                   = 1000,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_INCOMING_REJECTED                      = 1001,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_GATEWAY_SERVICE                     = 1002,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_GPRS_CONTEXT                        = 1003,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ILLEGAL_MS                             = 1004,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ILLEGAL_ME                             = 1005,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_GPRS_AND_NON_GPRS_SERVICES_NOT_ALLOWED = 1006,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_GPRS_SERVICES_NOT_ALLOWED              = 1007,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_MS_IDENTITY_NOT_DERIVED_BY_THE_NETWORK = 1008,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_IMPLICITLY_DETACHED                    = 1009,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_PLMN_NOT_ALLOWED                       = 1010,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_LA_NOT_ALLOWED                         = 1011,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_GPRS_SERVICES_NOT_ALLOWED_IN_PLMN      = 1012,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_PDP_DUPLICATE                          = 1013,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_UE_RAT_CHANGE                          = 1014,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONGESTION                             = 1015,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_PDP_CONTEXT_ACTIVATED               = 1016,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACCESS_CLASS_DSAC_REJECTION            = 1017,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONNECTION_DENY_GENERAL_OR_BUSY                   = 1500,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CONNECTION_DENY_BILLING_OR_AUTHENTICATION_FAILURE = 1501,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_CHANGE                                        = 1502,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_EXIT                                          = 1503,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_NO_SESSION                                    = 1504,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_ORIGINATION_DURING_GPS_FIX                    = 1505,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_CONNECTION_SETUP_TIMEOUT                      = 1506,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_HDR_RELEASED_BY_CM                                = 1507,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_HYBRID_HDR_SERVICE                             = 1510,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_CLIENT_END                 = 2000,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_NO_SERVICE                 = 2001,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_FADE                       = 2002,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_RELEASE_NORMAL             = 2003,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACCESS_ATTEMPT_IN_PROGRESS = 2004,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_ACCESS_FAILURE             = 2005,
+    QMI_WDS_VERBOSE_CALL_END_REASON_CM_REDIRECTION_OR_HANDOFF     = 2006
+} QmiWdsVerboseCallEndReasonCm;
+
+/**
+ * QmiWdsVerboseCallEndReason3gpp:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPERATOR_DETERMINED_BARRING: Operator-determined barring.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_LLC_SNDCP_FAILURE: LLC or SNDCP failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_INSUFFICIENT_RESOURCES: Insufficient resources.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_APN:  Unknown or missing APN.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_PDP: Unknown PDP address or type.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_AUTHENTICATION_FAILED: Authentication failed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_GGSN_REJECT: Activation rejected by GGSN.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_ACTIVATION_REJECT: Activation rejected.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPTION_NOT_SUPPORTED:  Service option not supported.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPTION_UNSUBSCRIBED: Service option not subscribed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPTION_TEMPORARILY_OUT_OF_ORDER: Service option temporarily out of order.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_NSAPI_ALREADY_USED: NSAPI already used.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_REGULAR_DEACTIVATION: Regular PDP context deactivation.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_QOS_NOT_ACCEPTED: QoS not accepted.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_NETWORK_FAILURE: Network failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_REATTACH_REQUIRED: Reattach required.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_FEATURE_NOT_SUPPORTED: Feature not supported.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_TFT_SEMANTIC_ERROR: Semantic error in TFT operation.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_TFT_SYNTAX_ERROR: Syntax error in TFT operation.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_PDP_CONTEXT: Unknown PDP context.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_FILTER_SEMANTIC_ERROR: Semantic error in packet filters.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_FILTER_SYNTAX_ERROR: Syntax error in packet filters.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_PDP_WITHOUT_ACTIVE_TFT: PDP context without TFT activated.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_IPV4_ONLY_ALLOWED: IPv4 only allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_IPV6_ONLY_ALLOWED: IPv6 only allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_SINGLE_ADDRESS_BEARER_ONLY: Single address bearer only.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_ESM_INFO_NOT_RECEIVED: ESM information not received.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_PDN_CONNECTION_DOES_NOT_EXIST: PDN connection does not exist.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MULTIPLE_CONNECTION_TO_SAME_PDN_NOT_ALLOWED: Multiple connection to same PDN not allowed.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_INVALID_TRANSACTION_ID: Invalid transaction ID.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_INCORRECT_SEMANTIC: Message incorrect semantically.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_INVALID_MANDATORY_INFO:  Invalid mandatory information.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_TYPE_UNSUPPORTED: Message type not implemented.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_TYPE_NONCOMPATIBLE_STATE: Message not compatible with state.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_INFO_ELEMENT: Information element unknown.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_CONDITIONAL_IE_ERROR: Conditional IE error.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_AND_PROTOCOL_STATE_UNCOMPATIBLE: Message and protocol state uncompatible.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_PROTOCOL_ERROR: Protocol error.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_APN_TYPE_CONFLICT: APN type conflict.
+ *
+ * 3GPP-specific call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_3GPP.
+ */
+typedef enum { /*< underscore_name=qmi_wds_verbose_call_end_reason_3gpp >*/
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPERATOR_DETERMINED_BARRING = 8,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_LLC_SNDCP_FAILURE               = 25,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_INSUFFICIENT_RESOURCES          = 26,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_APN                     = 27,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_PDP                     = 28,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_AUTHENTICATION_FAILED           = 29,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_GGSN_REJECT                     = 30,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_ACTIVATION_REJECT               = 31,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPTION_NOT_SUPPORTED            = 32,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPTION_UNSUBSCRIBED             = 33,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_OPTION_TEMPORARILY_OUT_OF_ORDER = 34,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_NSAPI_ALREADY_USED              = 35,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_REGULAR_DEACTIVATION            = 36,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_QOS_NOT_ACCEPTED                = 37,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_NETWORK_FAILURE                 = 38,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_REATTACH_REQUIRED               = 39,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_FEATURE_NOT_SUPPORTED           = 40,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_TFT_SEMANTIC_ERROR              = 41,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_TFT_SYNTAX_ERROR                = 42,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_PDP_CONTEXT             = 43,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_FILTER_SEMANTIC_ERROR           = 44,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_FILTER_SYNTAX_ERROR             = 45,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_PDP_WITHOUT_ACTIVE_TFT          = 46,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_IPV4_ONLY_ALLOWED                           = 50,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_IPV6_ONLY_ALLOWED                           = 51,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_SINGLE_ADDRESS_BEARER_ONLY                  = 52,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_ESM_INFO_NOT_RECEIVED                       = 53,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_PDN_CONNECTION_DOES_NOT_EXIST               = 54,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MULTIPLE_CONNECTION_TO_SAME_PDN_NOT_ALLOWED = 55,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_INVALID_TRANSACTION_ID = 81,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_INCORRECT_SEMANTIC              = 95,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_INVALID_MANDATORY_INFO                  = 96,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_TYPE_UNSUPPORTED                = 97,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_TYPE_NONCOMPATIBLE_STATE        = 98,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_UNKNOWN_INFO_ELEMENT                    = 99,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_CONDITIONAL_IE_ERROR                    = 100,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_MESSAGE_AND_PROTOCOL_STATE_UNCOMPATIBLE = 101,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_PROTOCOL_ERROR    = 111,
+    QMI_WDS_VERBOSE_CALL_END_REASON_3GPP_APN_TYPE_CONFLICT = 112
+} QmiWdsVerboseCallEndReason3gpp;
+
+/**
+ * QmiWdsVerboseCallEndReasonPpp:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_PPP_UNKNOWN: Unknown error.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_PPP_TIMEOUT: Timeout.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_PPP_AUTHENTICATION_FAILURE: Authentication failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_PPP_OPTION_MISMATCH: Option mismatch.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_PPP_PAP_FAILURE: PAP failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_PPP_CHAP_FAILURE: CHAP failure.
+ *
+ * PPP-specific call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_PPP.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_PPP_UNKNOWN = -1,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_PPP_TIMEOUT                = 1,
+    QMI_WDS_VERBOSE_CALL_END_REASON_PPP_AUTHENTICATION_FAILURE = 2,
+    QMI_WDS_VERBOSE_CALL_END_REASON_PPP_OPTION_MISMATCH        = 3,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_PPP_PAP_FAILURE  = 31,
+    QMI_WDS_VERBOSE_CALL_END_REASON_PPP_CHAP_FAILURE = 32
+} QmiWdsVerboseCallEndReasonPpp;
+
+/**
+ * QmiWdsVerboseCallEndReasonEhrpd:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_SUBSCRIPTION_LIMITED_TO_IPV4: Subscription limited to IPv4.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_SUBSCRIPTION_LIMITED_TO_IPV6: Subscription limited to IPv6.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_TIMEOUT: (VSNCP) timeout.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_FAILURE: (VSNCP) failure.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_GENERAL_ERROR: (VSCNP) 3GPP2 general error.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_UNAUTHENTICATED_APN: (VSCNP) 3GPP2 unauthenticated APN.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_LIMIT_EXCEEDED: (VSCNP) 3GPP2 PDN limit exceeded.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_NO_PDN_GATEWAY: (VSCNP) 3GPP2 no PDN gateway.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_GATEWAY_UNREACHABLE: (VSCNP) 3GPP2 PDN gateway unreachable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_GATEWAY_REJECTED: (VSCNP) 3GPP2 PDN gateway rejected.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_INSUFFICIENT_PARAMETERS: (VSCNP) 3GPP2 insufficient parameters.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_RESOURCE_UNAVAILABLE: (VSCNP) 3GPP2 resource unavailable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_ADMINISTRATIVELY_PROHIBITED: (VSCNP) 3GPP2 administratively prohibited.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_ID_IN_USE: (VSCNP) 3GPP2 PDN ID in use.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_SUBSCRIPTION_LIMITATION: (VSCNP) 3GPP2 subscription limitation.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_EXISTS_FOR_THIS_APN: (VSCNP) 3GPP2 PDN exists for this APN.
+ *
+ * eHRPD-specific call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_EHRPD.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_SUBSCRIPTION_LIMITED_TO_IPV4 = 1,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_SUBSCRIPTION_LIMITED_TO_IPV6 = 2,
+
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_TIMEOUT                           = 4,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_FAILURE                           = 5,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_GENERAL_ERROR               = 6,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_UNAUTHENTICATED_APN         = 7,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_LIMIT_EXCEEDED          = 8,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_NO_PDN_GATEWAY              = 9,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_GATEWAY_UNREACHABLE     = 10,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_GATEWAY_REJECTED        = 11,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_INSUFFICIENT_PARAMETERS     = 12,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_RESOURCE_UNAVAILABLE        = 13,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_ADMINISTRATIVELY_PROHIBITED = 14,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_ID_IN_USE               = 15,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_SUBSCRIPTION_LIMITATION     = 16,
+    QMI_WDS_VERBOSE_CALL_END_REASON_EHRPD_VSNCP_3GPP2_PDN_EXISTS_FOR_THIS_APN     = 17
+} QmiWdsVerboseCallEndReasonEhrpd;
+
+/**
+ * QmiWdsVerboseCallEndReasonIpv6:
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_IPV6_PREFIX_UNAVAILABLE: Prefix unavailable.
+ * @QMI_WDS_VERBOSE_CALL_END_REASON_IPV6_HRPD_IPV6_DISABLED: HRDP IPv6 disabled.
+ *
+ * IPv6-specific call end reasons, given when the @QmiWdsVerboseCallEndReasonType is #QMI_WDS_VERBOSE_CALL_END_REASON_TYPE_IPV6.
+ */
+typedef enum {
+    QMI_WDS_VERBOSE_CALL_END_REASON_IPV6_PREFIX_UNAVAILABLE = 1,
+    QMI_WDS_VERBOSE_CALL_END_REASON_IPV6_HRPD_IPV6_DISABLED = 2
+} QmiWdsVerboseCallEndReasonIpv6;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WDS Get Packet Service Status' message */
+
+/**
+ * QmiWdsConnectionStatus:
+ * @QMI_WDS_CONNECTION_STATUS_UNKNOWN: Unknown status.
+ * @QMI_WDS_CONNECTION_STATUS_DISCONNECTED: Network is disconnected
+ * @QMI_WDS_CONNECTION_STATUS_CONNECTED: Network is connected.
+ * @QMI_WDS_CONNECTION_STATUS_SUSPENDED: Network connection is suspended.
+ * @QMI_WDS_CONNECTION_STATUS_AUTHENTICATING: Network authentication is ongoing.
+ *
+ * Status of the network connection.
+ */
+typedef enum {
+    QMI_WDS_CONNECTION_STATUS_UNKNOWN        = 0,
+    QMI_WDS_CONNECTION_STATUS_DISCONNECTED   = 1,
+    QMI_WDS_CONNECTION_STATUS_CONNECTED      = 2,
+    QMI_WDS_CONNECTION_STATUS_SUSPENDED      = 3,
+    QMI_WDS_CONNECTION_STATUS_AUTHENTICATING = 4
+} QmiWdsConnectionStatus;
+
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WDS Get Data Bearer Technology' message */
+
+/**
+ * QmiWdsDataBearerTechnology:
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_UNKNOWN: Unknown.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_CDMA20001X: CDMA2000 1x.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_1xEVDO: CDMA2000 HRPD 1xEV-DO.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_GSM: GSM.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_UMTS: UMTS.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_1xEVDO_REVA: CDMA2000 HRPD 1xEV-DO RevA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_EDGE: EDGE.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPA: HSDPA and WCDMA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_HSUPA: WCDMA and HSUPA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPA_HSUPDA: HSDPA and HSUPA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_LTE: LTE.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_EHRPD: CDMA2000 eHRPD.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPAPLUS: HSDPA+ and WCDMA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPAPLUS_HSUPA: HSDPA+ and HSUPA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_DCHSDPAPLUS: DC-HSDPA+ and WCDMA.
+ * @QMI_WDS_DATA_BEARER_TECHNOLOGY_DCHSDPAPLUS_HSUPA: DC-HSDPA+ and HSUPA.
+ *
+ * Data bearer technology.
+ */
+typedef enum {
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_UNKNOWN           = -1,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_CDMA20001X        = 0x01,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_1xEVDO            = 0x02,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_GSM               = 0x03,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_UMTS              = 0x04,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_1xEVDO_REVA       = 0x05,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_EDGE              = 0x06,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPA             = 0x07,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_HSUPA             = 0x08,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPA_HSUPDA      = 0x09,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_LTE               = 0x0A,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_EHRPD             = 0x0B,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPAPLUS         = 0x0C,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_HSDPAPLUS_HSUPA   = 0x0D,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_DCHSDPAPLUS       = 0x0E,
+    QMI_WDS_DATA_BEARER_TECHNOLOGY_DCHSDPAPLUS_HSUPA = 0x0F
+} QmiWdsDataBearerTechnology;
+
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WDS Get Current Data Bearer Technology' message */
+
+/**
+ * QmiWdsNetworkType:
+ * @QMI_WDS_NETWORK_TYPE_UNKNOWN: Unknown.
+ * @QMI_WDS_NETWORK_TYPE_3GPP2: 3GPP2 network type.
+ * @QMI_WDS_NETWORK_TYPE_3GPP: 3GPP network type.
+ *
+ * Network type of the data bearer.
+ */
+typedef enum {
+    QMI_WDS_NETWORK_TYPE_UNKNOWN = 0,
+    QMI_WDS_NETWORK_TYPE_3GPP2   = 1,
+    QMI_WDS_NETWORK_TYPE_3GPP    = 2
+} QmiWdsNetworkType;
+
+/**
+ * QmiWdsRat3gpp2:
+ * @QMI_WDS_RAT_3GPP2_NONE: Unknown, to be ignored.
+ * @QMI_WDS_RAT_3GPP2_CDMA1X: CDMA 1x.
+ * @QMI_WDS_RAT_3GPP2_EVDO_REV0: EVDO Rev0.
+ * @QMI_WDS_RAT_3GPP2_EVDO_REVA: EVDO RevA.
+ * @QMI_WDS_RAT_3GPP2_EVDO_REVB: EVDO RevB.
+ * @QMI_WDS_RAT_3GPP2_NULL_BEARER: No bearer.
+ *
+ * Flags specifying the 3GPP2-specific Radio Access Technology, when the data
+ * bearer network type is @QMI_WDS_NETWORK_TYPE_3GPP2.
+ */
+typedef enum { /*< underscore_name=qmi_wds_rat_3gpp2 >*/
+    QMI_WDS_RAT_3GPP2_NONE        = 0,
+    QMI_WDS_RAT_3GPP2_CDMA1X      = 1 << 0,
+    QMI_WDS_RAT_3GPP2_EVDO_REV0   = 1 << 1,
+    QMI_WDS_RAT_3GPP2_EVDO_REVA   = 1 << 2,
+    QMI_WDS_RAT_3GPP2_EVDO_REVB   = 1 << 3,
+    QMI_WDS_RAT_3GPP2_NULL_BEARER = 1 << 15
+} QmiWdsRat3gpp2;
+
+/**
+ * QmiWdsRat3gpp:
+ * @QMI_WDS_RAT_3GPP_NONE: Unknown, to be ignored.
+ * @QMI_WDS_RAT_3GPP_WCDMA: WCDMA.
+ * @QMI_WDS_RAT_3GPP_GPRS: GPRS.
+ * @QMI_WDS_RAT_3GPP_HSDPA: HSDPA.
+ * @QMI_WDS_RAT_3GPP_HSUPA: HSUPA.
+ * @QMI_WDS_RAT_3GPP_EDGE: EDGE.
+ * @QMI_WDS_RAT_3GPP_LTE: LTE.
+ * @QMI_WDS_RAT_3GPP_HSDPAPLUS: HSDPA+.
+ * @QMI_WDS_RAT_3GPP_DCHSDPAPLUS: DC-HSDPA+
+ * @QMI_WDS_RAT_3GPP_NULL_BEARER: No bearer.
+ *
+ * Flags specifying the 3GPP-specific Radio Access Technology, when the data
+ * bearer network type is @QMI_WDS_NETWORK_TYPE_3GPP.
+ */
+typedef enum { /*< underscore_name=qmi_wds_rat_3gpp >*/
+    QMI_WDS_RAT_3GPP_NONE        = 0,
+    QMI_WDS_RAT_3GPP_WCDMA       = 1 << 0,
+    QMI_WDS_RAT_3GPP_GPRS        = 1 << 1,
+    QMI_WDS_RAT_3GPP_HSDPA       = 1 << 2,
+    QMI_WDS_RAT_3GPP_HSUPA       = 1 << 3,
+    QMI_WDS_RAT_3GPP_EDGE        = 1 << 4,
+    QMI_WDS_RAT_3GPP_LTE         = 1 << 5,
+    QMI_WDS_RAT_3GPP_HSDPAPLUS   = 1 << 6,
+    QMI_WDS_RAT_3GPP_DCHSDPAPLUS = 1 << 7,
+    QMI_WDS_RAT_3GPP_NULL_BEARER = 1 << 15
+} QmiWdsRat3gpp;
+
+/**
+ * QmiWdsSoCdma1x:
+ * @QMI_WDS_SO_CDMA1X_NONE: Unknown, to be ignored.
+ * @QMI_WDS_SO_CDMA1X_IS95: IS95.
+ * @QMI_WDS_SO_CDMA1X_IS2000: IS2000.
+ * @QMI_WDS_SO_CDMA1X_IS2000_REL_A: IS2000 RelA.
+ *
+ * Flags specifying the Service Option when the bearer network type is
+ * @QMI_WDS_NETWORK_TYPE_3GPP2 and when the Radio Access Technology mask
+ * contains @QMI_WDS_RAT_3GPP2_CDMA1X.
+ */
+typedef enum {
+    QMI_WDS_SO_CDMA1X_NONE         = 0,
+    QMI_WDS_SO_CDMA1X_IS95         = 1 << 0,
+    QMI_WDS_SO_CDMA1X_IS2000       = 1 << 1,
+    QMI_WDS_SO_CDMA1X_IS2000_REL_A = 1 << 2
+} QmiWdsSoCdma1x;
+
+/**
+ * QmiWdsSoEvdoRevA:
+ * @QMI_WDS_SO_EVDO_REVA_NONE: Unknown, to be ignored.
+ * @QMI_WDS_SO_EVDO_REVA_DPA: DPA.
+ * @QMI_WDS_SO_EVDO_REVA_MFPA: MFPA.
+ * @QMI_WDS_SO_EVDO_REVA_EMPA: EMPA.
+ * @QMI_WDS_SO_EVDO_REVA_EMPA_EHRPD: EMPA EHRPD.
+ *
+ * Flags specifying the Service Option when the bearer network type is
+ * @QMI_WDS_NETWORK_TYPE_3GPP2 and when the Radio Access Technology mask
+ * contains @QMI_WDS_RAT_3GPP2_EVDO_REVA.
+ */
+typedef enum { /*< underscore_name=qmi_wds_so_evdo_reva >*/
+    QMI_WDS_SO_EVDO_REVA_NONE       = 0,
+    QMI_WDS_SO_EVDO_REVA_DPA        = 1 << 0,
+    QMI_WDS_SO_EVDO_REVA_MFPA       = 1 << 1,
+    QMI_WDS_SO_EVDO_REVA_EMPA       = 1 << 2,
+    QMI_WDS_SO_EVDO_REVA_EMPA_EHRPD = 1 << 3
+} QmiWdsSoEvdoRevA;
+
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WDS Get Current Settings' message */
+
+/**
+ * QmiWdsGetCurrentSettingsRequestedSettings:
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_NONE: no settings requested
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PROFILE_ID: request profile ID
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PROFILE_NAME: request profile name
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PDP_TYPE: request PDP context type
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_APN_NAME: request APN name
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_DNS_ADDRESS: request DNS server addresses
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_GRANTED_QOS: request granted QoS
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_USERNAME: request username
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_AUTH_PROTOCOL: request authentication protocol (ie PAP/CHAP/none)
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_IP_ADDRESS: request IP address
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_GATEWAY_INFO: request gateway address
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PCSCF_ADDRESS: request PCSCF address
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PCSCF_SERVER_ADDRESS_LIST: request PCSCF server address list
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PCSCF_DOMAIN_NAME_LIST: request PCSCF domain name list
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_MTU: request MTU
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_DOMAIN_NAME_LIST: request domain name list
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_IP_FAMILY: request IP family (ie IPv4 or IPv6)
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_IMCN_FLAG: request IMCN flag
+ * @QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_EXTENDED_TECHNOLOGY: request extended technology info
+ *
+ * Flags specifying which specific settings to return when requesting the
+ * current WDS bearer settings.
+ */
+typedef enum { /*< underscore_name=qmi_wds_get_current_settings_requested_settings >*/
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_NONE                      = 0,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PROFILE_ID                = 1 << 0,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PROFILE_NAME              = 1 << 1,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PDP_TYPE                  = 1 << 2,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_APN_NAME                  = 1 << 3,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_DNS_ADDRESS               = 1 << 4,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_GRANTED_QOS               = 1 << 5,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_USERNAME                  = 1 << 6,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_AUTH_PROTOCOL             = 1 << 7,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_IP_ADDRESS                = 1 << 8,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_GATEWAY_INFO              = 1 << 9,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PCSCF_ADDRESS             = 1 << 10,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PCSCF_SERVER_ADDRESS_LIST = 1 << 11,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_PCSCF_DOMAIN_NAME_LIST    = 1 << 12,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_MTU                       = 1 << 13,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_DOMAIN_NAME_LIST          = 1 << 14,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_IP_FAMILY                 = 1 << 15,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_IMCN_FLAG                 = 1 << 16,
+    QMI_WDS_GET_CURRENT_SETTINGS_REQUESTED_SETTINGS_EXTENDED_TECHNOLOGY       = 1 << 17,
+} QmiWdsGetCurrentSettingsRequestedSettings;
+
+/**
+ * QmiWdsPdpType:
+ * @QMI_WDS_PDP_TYPE_IPV4: IPv4
+ * @QMI_WDS_PDP_TYPE_PPP: PPP
+ * @QMI_WDS_PDP_TYPE_IPV6: IPv6
+ * @QMI_WDS_PDP_TYPE_IPV4_OR_IPV6: IPv4 and IPv6 combined context
+ *
+ * PDP context type.
+ */
+typedef enum { /*< underscore_name=qmi_wds_pdp_type >*/
+    QMI_WDS_PDP_TYPE_IPV4         = 0,
+    QMI_WDS_PDP_TYPE_PPP          = 1,
+    QMI_WDS_PDP_TYPE_IPV6         = 2,
+    QMI_WDS_PDP_TYPE_IPV4_OR_IPV6 = 3
+} QmiWdsPdpType;
+
+/**
+ * QmiWdsTrafficClass:
+ * @QMI_WDS_TRAFFIC_CLASS_SUBSCRIBED: default (?) class, best-effort
+ * @QMI_WDS_TRAFFIC_CLASS_CONVERSATIONAL: two-way video/voice, most delay sensitive
+ * @QMI_WDS_TRAFFIC_CLASS_STREAMING: one-way video/audio, delay sensitive
+ * @QMI_WDS_TRAFFIC_CLASS_INTERACTIVE: delay-insensitive (browsing, SSH)
+ * @QMI_WDS_TRAFFIC_CLASS_BACKGROUND: delay-insensitive (downloads, email)
+ *
+ * QoS Traffic Classes.
+ */
+typedef enum { /*< underscore_name=qmi_wds_traffic_class >*/
+    QMI_WDS_TRAFFIC_CLASS_SUBSCRIBED     = 0,
+    QMI_WDS_TRAFFIC_CLASS_CONVERSATIONAL = 1,
+    QMI_WDS_TRAFFIC_CLASS_STREAMING      = 2,
+    QMI_WDS_TRAFFIC_CLASS_INTERACTIVE    = 3,
+    QMI_WDS_TRAFFIC_CLASS_BACKGROUND     = 4
+} QmiWdsTrafficClass;
+
+/**
+ * QmiWdsAuthentication:
+ * @QMI_WDS_AUTHENTICATION_NONE: no authentication
+ * @QMI_WDS_AUTHENTICATION_PAP: PAP authentication
+ * @QMI_WDS_AUTHENTICATION_CHAP: CHAP authentication
+ *
+ * PDP context authentication protocols.
+ */
+typedef enum { /*< underscore_name=qmi_wds_authentication >*/
+    QMI_WDS_AUTHENTICATION_NONE = 0,
+    QMI_WDS_AUTHENTICATION_PAP  = 1 << 0,
+    QMI_WDS_AUTHENTICATION_CHAP = 1 << 1
+} QmiWdsAuthentication;
+
+/**
+ * QmiWdsProfileType:
+ * @QMI_WDS_PROFILE_TYPE_3GPP: 3GPP profile type.
+ * @QMI_WDS_PROFILE_TYPE_3GPP2: 3GPP2 profile type.
+ *
+ * Profile network type family.
+ */
+typedef enum {
+    QMI_WDS_PROFILE_TYPE_3GPP    = 0,
+    QMI_WDS_PROFILE_TYPE_3GPP2   = 1
+} QmiWdsProfileType;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WDS Get Packet Statistics' message */
+
+/**
+ * QmiWdsPacketStatisticsMaskFlag:
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_OK: Request count of correctly sent packets.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_OK: Request count of correctly received packets.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_ERROR: Request count of sent packets with error.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_ERROR: Request count of received packets with error.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_OVERFLOWS: Request count of transmitter overflows.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_OVERFLOWS: Request count of receiver overflows.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_BYTES_OK: Request count of correctly sent bytes.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_BYTES_OK: Request count of correctly received bytes.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_DROPPED: Request count of dropped packets in transmission.
+ * @QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_DROPPED: Request count of dropped packets in reception.
+ *
+ * Mask to use when requesting packet statistics.
+ */
+typedef enum {
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_OK      = 1 << 0,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_OK      = 1 << 1,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_ERROR   = 1 << 2,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_ERROR   = 1 << 3,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_OVERFLOWS       = 1 << 4,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_OVERFLOWS       = 1 << 5,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_BYTES_OK        = 1 << 6,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_BYTES_OK        = 1 << 7,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_TX_PACKETS_DROPPED = 1 << 8,
+    QMI_WDS_PACKET_STATISTICS_MASK_FLAG_RX_PACKETS_DROPPED = 1 << 9
+} QmiWdsPacketStatisticsMaskFlag;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_WDS_H_ */
diff --git a/src/libqmi-glib/qmi-enums-wms.h b/src/libqmi-glib/qmi-enums-wms.h
new file mode 100644
index 0000000..d2df5bc
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums-wms.h
@@ -0,0 +1,429 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_WMS_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_WMS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums-wms
+ * @title: WMS enumerations and flags
+ *
+ * This section defines enumerations and flags used in the WMS service
+ * interface.
+ */
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WMS Event Report' indication */
+
+/**
+ * QmiWmsStorageType:
+ * @QMI_WMS_STORAGE_TYPE_UIM: Message stored in UIM.
+ * @QMI_WMS_STORAGE_TYPE_NV: Message stored in non-volatile memory.
+ * @QMI_WMS_STORAGE_TYPE_NONE: None.
+ *
+ * Type of messaging storage
+ */
+typedef enum {
+    QMI_WMS_STORAGE_TYPE_UIM  = 0x00,
+    QMI_WMS_STORAGE_TYPE_NV   = 0x01,
+    QMI_WMS_STORAGE_TYPE_NONE = 0xFF
+} QmiWmsStorageType;
+
+/**
+ * QmiWmsAckIndicator:
+ * @QMI_WMS_ACK_INDICATOR_SEND: ACK needs to be sent.
+ * @QMI_WMS_ACK_INDICATOR_DO_NOT_SEND: ACK doesn't need to be sent.
+ *
+ * Indication of whether ACK needs to be sent or not.
+ */
+typedef enum {
+    QMI_WMS_ACK_INDICATOR_SEND        = 0x00,
+    QMI_WMS_ACK_INDICATOR_DO_NOT_SEND = 0x01
+} QmiWmsAckIndicator;
+
+/**
+ * QmiWmsMessageFormat:
+ * @QMI_WMS_MESSAGE_FORMAT_CDMA: CDMA message.
+ * @QMI_WMS_MESSAGE_FORMAT_GSM_WCDMA_POINT_TO_POINT: Point-to-point 3GPP message.
+ * @QMI_WMS_MESSAGE_FORMAT_GSM_WCDMA_BROADCAST: Broadcast 3GPP message.
+ * @QMI_WMS_MESSAGE_FORMAT_MWI: Message Waiting Indicator.
+ *
+ * Type of message.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_FORMAT_CDMA                     = 0x00,
+    QMI_WMS_MESSAGE_FORMAT_GSM_WCDMA_POINT_TO_POINT = 0x06,
+    QMI_WMS_MESSAGE_FORMAT_GSM_WCDMA_BROADCAST      = 0x07,
+    QMI_WMS_MESSAGE_FORMAT_MWI                      = 0x08
+} QmiWmsMessageFormat;
+
+/**
+ * QmiWmsMessageMode:
+ * @QMI_WMS_MESSAGE_MODE_CDMA: Message sent using 3GPP2 technologies.
+ * @QMI_WMS_MESSAGE_MODE_GSM_WCDMA: Message sent using 3GPP technologies.
+ *
+ * Message mode.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_MODE_CDMA      = 0x00,
+    QMI_WMS_MESSAGE_MODE_GSM_WCDMA = 0x01
+} QmiWmsMessageMode;
+
+/**
+ * QmiWmsNotificationType:
+ * @QMI_WMS_NOTIFICATION_TYPE_PRIMARY: Primary.
+ * @QMI_WMS_NOTIFICATION_TYPE_SECONDARY_GSM: Secondary GSM.
+ * @QMI_WMS_NOTIFICATION_TYPE_SECONDARY_UMTS: Secondary UMTS.
+ *
+ * Type of notification.
+ */
+typedef enum {
+    QMI_WMS_NOTIFICATION_TYPE_PRIMARY        = 0x00,
+    QMI_WMS_NOTIFICATION_TYPE_SECONDARY_GSM  = 0x01,
+    QMI_WMS_NOTIFICATION_TYPE_SECONDARY_UMTS = 0x02
+} QmiWmsNotificationType;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WMS Raw Send' request/response */
+
+/**
+ * QmiWmsCdmaServiceOption:
+ * @QMI_WMS_CDMA_SERVICE_OPTION_AUTO: Automatic selection of service option.
+ * @QMI_WMS_CDMA_SERVICE_OPTION_6: Use service option 6.
+ * @QMI_WMS_CDMA_SERVICE_OPTION_14: Use service option 14.
+ *
+ * CDMA service option selection.
+ */
+typedef enum {
+    QMI_WMS_CDMA_SERVICE_OPTION_AUTO = 0x00,
+    QMI_WMS_CDMA_SERVICE_OPTION_6    = 0x06,
+    QMI_WMS_CDMA_SERVICE_OPTION_14   = 0x0E
+} QmiWmsCdmaServiceOption;
+
+/**
+ * QmiWmsCdmaCauseCode:
+ * @QMI_WDS_CDMA_CAUSE_CODE_NETWORK_ADDRESS_VACANT: Address is valid but not yet allocated.
+ * @QMI_WDS_CDMA_CAUSE_CODE_NETWORK_ADDRESS_TRANSLATION_FAILURE: Address is invalid.
+ * @QMI_WDS_CDMA_CAUSE_CODE_NETWORK_RESOURCE_SHORTAGE: Network resource shortage.
+ * @QMI_WDS_CDMA_CAUSE_CODE_NETWORK_FAILURE: Network failed.
+ * @QMI_WDS_CDMA_CAUSE_CODE_NETWORK_INVALID_TELESERVICE_ID: SMS teleservice ID is invalid.
+ * @QMI_WDS_CDMA_CAUSE_CODE_NETWORK_OTHER: Other network error.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_NO_PAGE_RESPONSE: No page response from destination.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_BUSY: Destination is busy.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_NO_ACK: No acknowledge from destination.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_RESOURCE_SHORTAGE: Destination resource shortage.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_SMS_DELIVERY_POSTPONED: SMS deliver postponed.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_OUT_OF_SERVICE: Destination out of service.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_NOT_AT_ADDRESS: Destination not at address.
+ * @QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_OTHER: Other destination error.
+ * @QMI_WDS_CDMA_CAUSE_CODE_RADIO_INTERFACE_RESOURCE_SHORTAGE: Radio interface resource shortage.
+ * @QMI_WDS_CDMA_CAUSE_CODE_RADIO_INTERFACE_INCOMPATIBILITY: Radio interface incompatibility.
+ * @QMI_WDS_CDMA_CAUSE_CODE_RADIO_INTERFACE_OTHER: Other radio interface error.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_ENCODING: Encoding error.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SMS_ORIGIN_DENIED: SMS origin denied.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SMS_DESTINATION_DENIED: SMS destination denied.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SUPPLEMENTARY_SERVICE_NOT_SUPPORTED: Supplementary service not supported.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SMS_NOT_SUPPORTED: SMS not supported.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_MISSING_EXPECTED_PARAMETER: Missing optional expected parameter.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_MISSING_MANDATORY_PARAMETER: Missing mandatory parameter.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_UNRECOGNIZED_PARAMETER_VALUE: Unrecognized parameter value.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_UNEXPECTED_PARAMETER_VALUE: Unexpected parameter value.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_USER_DATA_SIZE_ERROR: user data size error.
+ * @QMI_WDS_CDMA_CAUSE_CODE_GENERAL_OTHER: Other general error.
+ *
+ * Cause codes when failed to send an SMS in CDMA.
+ */
+typedef enum {
+    /* Network errors */
+    QMI_WDS_CDMA_CAUSE_CODE_NETWORK_ADDRESS_VACANT              = 0x00,
+    QMI_WDS_CDMA_CAUSE_CODE_NETWORK_ADDRESS_TRANSLATION_FAILURE = 0x01,
+    QMI_WDS_CDMA_CAUSE_CODE_NETWORK_RESOURCE_SHORTAGE           = 0x02,
+    QMI_WDS_CDMA_CAUSE_CODE_NETWORK_FAILURE                     = 0x03,
+    QMI_WDS_CDMA_CAUSE_CODE_NETWORK_INVALID_TELESERVICE_ID      = 0x04,
+    QMI_WDS_CDMA_CAUSE_CODE_NETWORK_OTHER                       = 0x05,
+
+    /* Destination errors */
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_NO_PAGE_RESPONSE       = 0x20,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_BUSY                   = 0x21,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_NO_ACK                 = 0x22,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_RESOURCE_SHORTAGE      = 0x23,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_SMS_DELIVERY_POSTPONED = 0x24,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_OUT_OF_SERVICE         = 0x25,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_NOT_AT_ADDRESS         = 0x26,
+    QMI_WDS_CDMA_CAUSE_CODE_DESTINATION_OTHER                  = 0x27,
+
+    /* Radio Interface errors */
+    QMI_WDS_CDMA_CAUSE_CODE_RADIO_INTERFACE_RESOURCE_SHORTAGE = 0x40,
+    QMI_WDS_CDMA_CAUSE_CODE_RADIO_INTERFACE_INCOMPATIBILITY   = 0x41,
+    QMI_WDS_CDMA_CAUSE_CODE_RADIO_INTERFACE_OTHER             = 0x42,
+
+    /* General errors */
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_ENCODING                            = 0x60,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SMS_ORIGIN_DENIED                   = 0x61,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SMS_DESTINATION_DENIED              = 0x62,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SUPPLEMENTARY_SERVICE_NOT_SUPPORTED = 0x63,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_SMS_NOT_SUPPORTED                   = 0x64,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_MISSING_EXPECTED_PARAMETER          = 0x65,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_MISSING_MANDATORY_PARAMETER         = 0x66,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_UNRECOGNIZED_PARAMETER_VALUE        = 0x67,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_UNEXPECTED_PARAMETER_VALUE          = 0x68,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_USER_DATA_SIZE_ERROR                = 0x69,
+    QMI_WDS_CDMA_CAUSE_CODE_GENERAL_OTHER                               = 0x6A
+} QmiWmsCdmaCauseCode;
+
+/**
+ * QmiWmsCdmaErrorClass:
+ * @QMI_WMS_CDMA_ERROR_CLASS_TEMPORARY: Temporary error.
+ * @QMI_WMS_CDMA_ERROR_CLASS_PERMANENT: Permanent error.
+ *
+ * Error class when failed to send an SMS in CDMA.
+ */
+typedef enum {
+    QMI_WMS_CDMA_ERROR_CLASS_TEMPORARY = 0x00,
+    QMI_WMS_CDMA_ERROR_CLASS_PERMANENT = 0x01
+} QmiWmsCdmaErrorClass;
+
+/**
+ * QmiWmsGsmUmtsRpCause:
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_UNASSIGNED_NUMBER: Unassigned number.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_OPERATOR_DETERMINED_BARRING: Operator determined barring.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_CALL_BARRED: Call barred.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_RESERVED: Reserved.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_SMS_TRANSFER_REJECTED: SMS transfer rejected.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_MEMORY_CAPACITY_EXCEEDED: Memory capacity exceeded.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_DESTINATION_OUT_OF_ORDER: Destination out of order.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_UNIDENTIFIED_SUBSCRIBER: Unidentified subscriber.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_FACILITY_REJECTED: Facility rejected.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_UNKNOWN_SUBSCRIBER: Unknown subscriber.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_NETWORK_OUF_OF_ORDER: Network out of order.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_TEMPORARY_FAILURE: Temporary failure.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_CONGESTION: Congestion.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_RESOURCES_UNAVAILABLE: Resources unavailable.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_FACILITY_NOT_SUBSCRIBED: Facility not subscribed.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_FACILITY_NOT_IMPLEMENTED: Facility not implemented.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_INVALID_SMS_TRANSFER_REFERENCE_VALUE: Invalid SMS transfer reference value.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_SEMANTICALLY_INCORRECT_MESSAGE: Semantically incorrect message.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_INVALID_MANDATORY_INFO: Invalid mandatory info.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_MESSAGE_TYPE_NOT_IMPLEMENTED: Message type not implemented.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_MESSAGE_NOT_COMPATIBLE_WITH_SMS: Message not compatible with SMS.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_INFORMATION_ELEMENT_NOT_IMPLEMENTED: Information element not implemented.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_PROTOCOL_ERROR: Protocol error.
+ * @QMI_WMS_GSM_UMTS_RP_CAUSE_INTERWORKING: Interworking error.
+ *
+ * RP cause codes when failed to send an SMS in GSM/WCDMA.
+ */
+typedef enum {
+    QMI_WMS_GSM_UMTS_RP_CAUSE_UNASSIGNED_NUMBER                    = 0x01,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_OPERATOR_DETERMINED_BARRING          = 0x08,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_CALL_BARRED                          = 0x0A,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_RESERVED                             = 0x0B,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_SMS_TRANSFER_REJECTED                = 0x15,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_MEMORY_CAPACITY_EXCEEDED             = 0x16,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_DESTINATION_OUT_OF_ORDER             = 0x1B,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_UNIDENTIFIED_SUBSCRIBER              = 0x1C,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_FACILITY_REJECTED                    = 0x1D,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_UNKNOWN_SUBSCRIBER                   = 0x1E,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_NETWORK_OUF_OF_ORDER                 = 0x20,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_TEMPORARY_FAILURE                    = 0x21,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_CONGESTION                           = 0x2A,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_RESOURCES_UNAVAILABLE                = 0x2F,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_FACILITY_NOT_SUBSCRIBED              = 0x32,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_FACILITY_NOT_IMPLEMENTED             = 0x45,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_INVALID_SMS_TRANSFER_REFERENCE_VALUE = 0x51,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_SEMANTICALLY_INCORRECT_MESSAGE       = 0x5F,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_INVALID_MANDATORY_INFO               = 0x60,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_MESSAGE_TYPE_NOT_IMPLEMENTED         = 0x61,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_MESSAGE_NOT_COMPATIBLE_WITH_SMS      = 0x62,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_INFORMATION_ELEMENT_NOT_IMPLEMENTED  = 0x63,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_PROTOCOL_ERROR                       = 0x6F,
+    QMI_WMS_GSM_UMTS_RP_CAUSE_INTERWORKING                         = 0x7F
+} QmiWmsGsmUmtsRpCause;
+
+/**
+ * QmiWmsGsmUmtsTpCause:
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_TELE_INTERWORKING_NOT_SUPPORTED: Tele interworking not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SHORT_MESSAGE_TYPE_0_NOT_SUPPORTED: Short message type 0 not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SHORT_MESSAGE_CANNOT_BE_REPLACED: Short message cannot be replaced.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_PID_ERROR: Unspecified TP-PID error.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_DCS_NOT_SUPPORTED: Data coding scheme not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_MESSAGE_CLASS_NOT_SUPPORTED: Message class not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_DCS_ERROR: Unspecified data coding scheme error.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_COMMAND_CANNOT_BE_ACTIONED: Command cannot be actioned.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_COMMAND_UNSUPPORTED: Command unsupported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_COMMAND_ERROR: Unspecified command error.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_TPDU_NOT_SUPPORTED: TPDU not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SC_BUSY: SC busy.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_NO_SC_SUBSCRIPTION: No SC subscription.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SC_SYSTEM_FAILURE: SC system failure.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_INVALID_SME_ADDRESS: Invalid SME address.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_DESTINATION_SME_BARRED: Destination SME barred.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SM_REJECTED_OR_DUPLICATE: SM rejected or duplicate.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_VPF_NOT_SUPPORTED: TP-VPF not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_VP_NOT_SUPPORTED: TP-VP not supported.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SIM_SMS_STORAGE_FULL: SIM SMS storage full.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_NO_SMS_STORAGE_CAPABILITY_IN_SIM: No SMS storage capability in SIM.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_MS_ERROR: MS error.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_MEMORY_CAPACITY_EXCEEDED: Memory capacity exceeded.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SIM_APPLICATION_TOOLKIT_BUSY: SIM application toolkit busy.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_SIM_DATA_DOWNLOAD_ERROR: SIM data download error.
+ * @QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_ERROR: Unspecified error.
+ *
+ * RT cause codes when failed to send an SMS in GSM/WCDMA.
+ */
+typedef enum {
+    QMI_WMS_GSM_UMTS_TP_CAUSE_TELE_INTERWORKING_NOT_SUPPORTED    = 0x80,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SHORT_MESSAGE_TYPE_0_NOT_SUPPORTED = 0x81,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SHORT_MESSAGE_CANNOT_BE_REPLACED   = 0x82,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_PID_ERROR              = 0x8F,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_DCS_NOT_SUPPORTED                  = 0x90,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_MESSAGE_CLASS_NOT_SUPPORTED        = 0x91,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_DCS_ERROR              = 0x9F,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_COMMAND_CANNOT_BE_ACTIONED         = 0xA0,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_COMMAND_UNSUPPORTED                = 0xA1,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_COMMAND_ERROR          = 0xAF,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_TPDU_NOT_SUPPORTED                 = 0xB0,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SC_BUSY                            = 0xC0,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_NO_SC_SUBSCRIPTION                 = 0xC1,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SC_SYSTEM_FAILURE                  = 0xC2,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_INVALID_SME_ADDRESS                = 0xC3,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_DESTINATION_SME_BARRED             = 0xC4,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SM_REJECTED_OR_DUPLICATE           = 0xC5,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_VPF_NOT_SUPPORTED                  = 0xC6,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_VP_NOT_SUPPORTED                   = 0xC7,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SIM_SMS_STORAGE_FULL               = 0xD0,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_NO_SMS_STORAGE_CAPABILITY_IN_SIM   = 0xD1,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_MS_ERROR                           = 0xD2,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_MEMORY_CAPACITY_EXCEEDED           = 0xD3,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SIM_APPLICATION_TOOLKIT_BUSY       = 0xD4,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_SIM_DATA_DOWNLOAD_ERROR            = 0xD5,
+    QMI_WMS_GSM_UMTS_TP_CAUSE_UNSPECIFIED_ERROR                  = 0xFF
+} QmiWmsGsmUmtsTpCause;
+
+/**
+ * QmiWmsMessageDeliveryFailureType:
+ * @QMI_WMS_MESSAGE_DELIVERY_FAILURE_TYPE_TEMPORARY: Temporary failure.
+ * @QMI_WMS_MESSAGE_DELIVERY_FAILURE_TYPE_PERMANENT: Permanent failure.
+ *
+ * Type of message delivery failure.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_DELIVERY_FAILURE_TYPE_TEMPORARY = 0x00,
+    QMI_WMS_MESSAGE_DELIVERY_FAILURE_TYPE_PERMANENT = 0x01
+} QmiWmsMessageDeliveryFailureType;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WMS Read Raw' request/response */
+
+/**
+ * QmiWmsMessageTagType:
+ * @QMI_WMS_MESSAGE_TAG_TYPE_MT_READ: Received SMS, already read.
+ * @QMI_WMS_MESSAGE_TAG_TYPE_MT_NOT_READ: Received SMS, not read.
+ * @QMI_WMS_MESSAGE_TAG_TYPE_MO_SENT: Sent SMS.
+ * @QMI_WMS_MESSAGE_TAG_TYPE_MO_NOT_SENT: Not yet sent SMS.
+ *
+ * Type of message tag.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_TAG_TYPE_MT_READ     = 0x00,
+    QMI_WMS_MESSAGE_TAG_TYPE_MT_NOT_READ = 0x01,
+    QMI_WMS_MESSAGE_TAG_TYPE_MO_SENT     = 0x02,
+    QMI_WMS_MESSAGE_TAG_TYPE_MO_NOT_SENT = 0x03
+} QmiWmsMessageTagType;
+
+/**
+ * QmiWmsMessageProtocol:
+ * @QMI_WMS_MESSAGE_PROTOCOL_CDMA: CDMA.
+ * @QMI_WMS_MESSAGE_PROTOCOL_WCDMA: WCDMA.
+ *
+ * Type of message protocol.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_PROTOCOL_CDMA  = 0x00,
+    QMI_WMS_MESSAGE_PROTOCOL_WCDMA = 0x01
+} QmiWmsMessageProtocol;
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI WMS Set Routes' request/response */
+
+/**
+ * QmiWmsMessageType:
+ * @QMI_WMS_MESSAGE_TYPE_POINT_TO_POINT: Point to point message.
+ *
+ * Type of message.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_TYPE_POINT_TO_POINT = 0x00
+} QmiWmsMessageType;
+
+/**
+ * QmiWmsMessageClass:
+ * @QMI_WMS_MESSAGE_CLASS_0: Class 0.
+ * @QMI_WMS_MESSAGE_CLASS_1: Class 1.
+ * @QMI_WMS_MESSAGE_CLASS_2: Class 2.
+ * @QMI_WMS_MESSAGE_CLASS_3: Class 3.
+ * @QMI_WMS_MESSAGE_CLASS_NONE: Class none.
+ * @QMI_WMS_MESSAGE_CLASS_CDMA: Class CDMA.
+ *
+ * Message class.
+ */
+typedef enum {
+    QMI_WMS_MESSAGE_CLASS_0    = 0x00,
+    QMI_WMS_MESSAGE_CLASS_1    = 0x01,
+    QMI_WMS_MESSAGE_CLASS_2    = 0x02,
+    QMI_WMS_MESSAGE_CLASS_3    = 0x03,
+    QMI_WMS_MESSAGE_CLASS_NONE = 0x04,
+    QMI_WMS_MESSAGE_CLASS_CDMA = 0x05
+} QmiWmsMessageClass;
+
+/**
+ * QmiWmsReceiptAction:
+ * @QMI_WMS_RECEIPT_ACTION_DISCARD: Discard message.
+ * @QMI_WMS_RECEIPT_ACTION_STORE_AND_NOTIFY: Store and notify to client.
+ * @QMI_WMS_RECEIPT_ACTION_TRANSFER_ONLY: Notify to client, which should send back ACK.
+ * @QMI_WMS_RECEIPT_ACTION_TRANSFER_AND_ACK: Notify to client and send back ACK.
+ * @QMI_WMS_RECEIPT_ACTION_UNKNOWN: Unknown action.
+ *
+ * Action to perform when a message is received.
+ */
+typedef enum {
+    QMI_WMS_RECEIPT_ACTION_DISCARD          = 0x00,
+    QMI_WMS_RECEIPT_ACTION_STORE_AND_NOTIFY = 0x01,
+    QMI_WMS_RECEIPT_ACTION_TRANSFER_ONLY    = 0x02,
+    QMI_WMS_RECEIPT_ACTION_TRANSFER_AND_ACK = 0x03,
+    QMI_WMS_RECEIPT_ACTION_UNKNOWN          = 0xFF
+} QmiWmsReceiptAction;
+
+/**
+ * QmiWmsTransferIndication:
+ * @QMI_WMS_TRANSFER_INDICATION_CLIENT: Status reports transferred to the client.
+ *
+ * Transfer indication actions.
+ */
+typedef enum {
+    QMI_WMS_TRANSFER_INDICATION_CLIENT = 0x01
+} QmiWmsTransferIndication;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_WMS_H_ */
diff --git a/src/libqmi-glib/qmi-enums.h b/src/libqmi-glib/qmi-enums.h
new file mode 100644
index 0000000..e3cba79
--- /dev/null
+++ b/src/libqmi-glib/qmi-enums.h
@@ -0,0 +1,105 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google, Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ENUMS_H_
+#define _LIBQMI_GLIB_QMI_ENUMS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-enums
+ * @title: Common enumerations and flags
+ *
+ * This section defines common enumerations and flags used in the interface.
+ */
+
+/**
+ * QmiService:
+ * @QMI_SERVICE_UNKNOWN: Unknown service.
+ * @QMI_SERVICE_CTL: Control service.
+ * @QMI_SERVICE_WDS: Wireless Data Service.
+ * @QMI_SERVICE_DMS: Device Management Service.
+ * @QMI_SERVICE_NAS: Network Access Service.
+ * @QMI_SERVICE_QOS: Quality Of Service service.
+ * @QMI_SERVICE_WMS: Wireless Messaging Service.
+ * @QMI_SERVICE_PDS: Position Determination Service.
+ * @QMI_SERVICE_AUTH: Authentication service.
+ * @QMI_SERVICE_AT: AT service.
+ * @QMI_SERVICE_VOICE: Voice service.
+ * @QMI_SERVICE_CAT2: Card Application Toolkit service (v2).
+ * @QMI_SERVICE_UIM: User Identity Module service.
+ * @QMI_SERVICE_PBM: Phonebook Management service.
+ * @QMI_SERVICE_LOC: Location service (~ PDS v2).
+ * @QMI_SERVICE_SAR: SAR.
+ * @QMI_SERVICE_RMTFS: Remote Filesystem service.
+ * @QMI_SERVICE_CAT: Card Application Toolkit service (v1).
+ * @QMI_SERVICE_RMS: Remote Management Service.
+ * @QMI_SERVICE_OMA: Open Mobile Alliance device management service.
+ *
+ * QMI services.
+ */
+typedef enum {
+    /* Unknown service */
+    QMI_SERVICE_UNKNOWN = -1,
+    /* Control service */
+    QMI_SERVICE_CTL = 0x00,
+    /* Wireless Data Service */
+    QMI_SERVICE_WDS = 0x01,
+    /* Device Management Service */
+    QMI_SERVICE_DMS = 0x02,
+    /* Network Access Service */
+    QMI_SERVICE_NAS = 0x03,
+    /* Quality Of Service service */
+    QMI_SERVICE_QOS = 0x04,
+    /* Wireless Messaging Service */
+    QMI_SERVICE_WMS = 0x05,
+    /* Position Determination Service */
+    QMI_SERVICE_PDS = 0x06,
+    /* Authentication service */
+    QMI_SERVICE_AUTH = 0x07,
+    /* AT service */
+    QMI_SERVICE_AT = 0x08,
+    /* Voice service */
+    QMI_SERVICE_VOICE = 0x09,
+    /* Card Application Toolkit service (major version 2) */
+    QMI_SERVICE_CAT2 = 0x0A,
+    /* User Identity Module service */
+    QMI_SERVICE_UIM = 0x0B,
+    /* Phonebook Management service */
+    QMI_SERVICE_PBM = 0x0C,
+    /* Location service (~ PDS major version 2) */
+    QMI_SERVICE_LOC = 0x10,
+    /* No idea what this one means.. Search And Rescue? */
+    QMI_SERVICE_SAR = 0x11,
+    /* Remote Filesystem service */
+    QMI_SERVICE_RMTFS = 0x14,
+    /* Card Application Toolkit service */
+    QMI_SERVICE_CAT = 0xE0,
+    /* Remote Management Service */
+    QMI_SERVICE_RMS = 0xE1,
+    /* Open Mobile Alliance device management service */
+    QMI_SERVICE_OMA = 0xE2
+} QmiService;
+
+#endif /* _LIBQMI_GLIB_QMI_ENUMS_H_ */
diff --git a/src/libqmi-glib/qmi-errors.h b/src/libqmi-glib/qmi-errors.h
new file mode 100644
index 0000000..d8e36b2
--- /dev/null
+++ b/src/libqmi-glib/qmi-errors.h
@@ -0,0 +1,279 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_ERRORS_H_
+#define _LIBQMI_GLIB_QMI_ERRORS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+/**
+ * SECTION: qmi-errors
+ * @title: Errors
+ *
+ * This section defines common error types used in the interface.
+ */
+
+/* Prefixes for errors registered in DBus */
+#define QMI_DBUS_ERROR_PREFIX          "org.freedesktop.libqmi.Error"
+#define QMI_CORE_ERROR_DBUS_PREFIX     QMI_DBUS_ERROR_PREFIX ".Core"
+#define QMI_PROTOCOL_ERROR_DBUS_PREFIX QMI_DBUS_ERROR_PREFIX ".Protocol"
+
+/**
+ * QmiCoreError:
+ * @QMI_CORE_ERROR_FAILED: Operation failed.
+ * @QMI_CORE_ERROR_WRONG_STATE: Operation cannot be executed in the current state.
+ * @QMI_CORE_ERROR_TIMEOUT: Operation timed out.
+ * @QMI_CORE_ERROR_INVALID_ARGS: Invalid arguments given.
+ * @QMI_CORE_ERROR_INVALID_MESSAGE: QMI message is invalid.
+ * @QMI_CORE_ERROR_TLV_NOT_FOUND: TLV not found.
+ * @QMI_CORE_ERROR_TLV_TOO_LONG: TLV is too long.
+ * @QMI_CORE_ERROR_UNSUPPORTED: Not supported.
+ *
+ * Common errors that may be reported by libqmi-glib.
+ */
+typedef enum { /*< underscore_name=qmi_core_error >*/
+    QMI_CORE_ERROR_FAILED           = 0, /*< nick=Failed >*/
+    QMI_CORE_ERROR_WRONG_STATE      = 1, /*< nick=WrongState >*/
+    QMI_CORE_ERROR_TIMEOUT          = 2, /*< nick=Timeout >*/
+    QMI_CORE_ERROR_INVALID_ARGS     = 3, /*< nick=InvalidArgs >*/
+    QMI_CORE_ERROR_INVALID_MESSAGE  = 4, /*< nick=InvalidMessage >*/
+    QMI_CORE_ERROR_TLV_NOT_FOUND    = 5, /*< nick=TlvNotFound >*/
+    QMI_CORE_ERROR_TLV_TOO_LONG     = 6, /*< nick=TlvTooLong >*/
+    QMI_CORE_ERROR_UNSUPPORTED      = 7  /*< nick=Unsupported >*/
+} QmiCoreError;
+
+/**
+ * QmiProtocolError:
+  * @QMI_PROTOCOL_ERROR_NONE: No error.
+  * @QMI_PROTOCOL_ERROR_MALFORMED_MESSAGE: Malformed message.
+  * @QMI_PROTOCOL_ERROR_NO_MEMORY: No memory.
+  * @QMI_PROTOCOL_ERROR_INTERNAL: Internal.
+  * @QMI_PROTOCOL_ERROR_ABORTED: Aborted.
+  * @QMI_PROTOCOL_ERROR_CLIENT_IDS_EXHAUSTED: Client IDs exhausted.
+  * @QMI_PROTOCOL_ERROR_UNABORTABLE_TRANSACTION: Unabortable transaction.
+  * @QMI_PROTOCOL_ERROR_INVALID_CLIENT_ID: Invalid client ID.
+  * @QMI_PROTOCOL_ERROR_NO_THRESHOLDS_PROVIDED: No thresholds provided.
+  * @QMI_PROTOCOL_ERROR_INVALID_HANDLE: Invalid handle.
+  * @QMI_PROTOCOL_ERROR_INVALID_PROFILE: Invalid profile.
+  * @QMI_PROTOCOL_ERROR_INVALID_PIN_ID: Invalid PIN ID.
+  * @QMI_PROTOCOL_ERROR_INCORRECT_PIN: Incorrect PIN.
+  * @QMI_PROTOCOL_ERROR_NO_NETWORK_FOUND: No network found.
+  * @QMI_PROTOCOL_ERROR_CALL_FAILED: Call failed.
+  * @QMI_PROTOCOL_ERROR_OUT_OF_CALL: Out of call.
+  * @QMI_PROTOCOL_ERROR_NOT_PROVISIONED: Not provisioned.
+  * @QMI_PROTOCOL_ERROR_MISSING_ARGUMENT: Missing argument.
+  * @QMI_PROTOCOL_ERROR_ARGUMENT_TOO_LONG: Argument too long.
+  * @QMI_PROTOCOL_ERROR_INVALID_TRANSACTION_ID: Invalid transaction ID.
+  * @QMI_PROTOCOL_ERROR_DEVICE_IN_USE: Device in use.
+  * @QMI_PROTOCOL_ERROR_NETWORK_UNSUPPORTED: Network unsupported.
+  * @QMI_PROTOCOL_ERROR_DEVICE_UNSUPPORTED: Device unsupported.
+  * @QMI_PROTOCOL_ERROR_NO_EFFECT: No effect.
+  * @QMI_PROTOCOL_ERROR_NO_FREE_PROFILE: No free profile.
+  * @QMI_PROTOCOL_ERROR_INVALID_PDP_TYPE: Invalid PDP type.
+  * @QMI_PROTOCOL_ERROR_INVALID_TECHNOLOGY_PREFERENCE: Invalid technology preference.
+  * @QMI_PROTOCOL_ERROR_INVALID_PROFILE_TYPE: Invalid profile type.
+  * @QMI_PROTOCOL_ERROR_INVALID_SERVICE_TYPE: Invalid service type.
+  * @QMI_PROTOCOL_ERROR_INVALID_REGISTER_ACTION: Invalid register action.
+  * @QMI_PROTOCOL_ERROR_INVALID_PS_ATTACH_ACTION: Invalid PS attach action.
+  * @QMI_PROTOCOL_ERROR_AUTHENTICATION_FAILED: Authentication failed.
+  * @QMI_PROTOCOL_ERROR_PIN_BLOCKED: PIN blocked.
+  * @QMI_PROTOCOL_ERROR_PIN_ALWAYS_BLOCKED: PIN always blocked.
+  * @QMI_PROTOCOL_ERROR_UIM_UNINITIALIZED: UIM uninitialized.
+  * @QMI_PROTOCOL_ERROR_MAXIMUM_QOS_REQUESTS_IN_USE: Maximum QoS requests in use.
+  * @QMI_PROTOCOL_ERROR_INCORRECT_FLOW_FILTER: Incorrect flow filter.
+  * @QMI_PROTOCOL_ERROR_NETWORK_QOS_UNAWARE: Network QoS unaware.
+  * @QMI_PROTOCOL_ERROR_INVALID_QOS_ID: Invalid QoS ID.
+  * @QMI_PROTOCOL_ERROR_QOS_UNAVAILABLE: QoS unavailable.
+  * @QMI_PROTOCOL_ERROR_FLOW_SUSPENDED: Flow suspended.
+  * @QMI_PROTOCOL_ERROR_GENERAL_ERROR: General error.
+  * @QMI_PROTOCOL_ERROR_UNKNOWN_ERROR: Unknown error.
+  * @QMI_PROTOCOL_ERROR_INVALID_ARGUMENT: Invalid argument.
+  * @QMI_PROTOCOL_ERROR_INVALID_INDEX: Invalid index.
+  * @QMI_PROTOCOL_ERROR_NO_ENTRY: No entry.
+  * @QMI_PROTOCOL_ERROR_DEVICE_STORAGE_FULL: Device storage full.
+  * @QMI_PROTOCOL_ERROR_DEVICE_NOT_READY: Device not ready.
+  * @QMI_PROTOCOL_ERROR_NETWORK_NOT_READY: Network not ready.
+  * @QMI_PROTOCOL_ERROR_WMS_CAUSE_CODE: WMS cause code.
+  * @QMI_PROTOCOL_ERROR_WMS_MESSAGE_NOT_SENT: WMS message not sent.
+  * @QMI_PROTOCOL_ERROR_WMS_MESSAGE_DELIVERY_FAILURE: WMS message delivery failure.
+  * @QMI_PROTOCOL_ERROR_WMS_INVALID_MESSAGE_ID: WMS invalid message ID.
+  * @QMI_PROTOCOL_ERROR_WMS_ENCODING: WMS encoding.
+  * @QMI_PROTOCOL_ERROR_AUTHENTICATION_LOCK: Authentication lock.
+  * @QMI_PROTOCOL_ERROR_INVALID_TRANSITION: Invalid transition.
+  * @QMI_PROTOCOL_ERROR_SESSION_INACTIVE: Session inactive.
+  * @QMI_PROTOCOL_ERROR_SESSION_INVALID: Session invalid.
+  * @QMI_PROTOCOL_ERROR_SESSION_OWNERSHIP: Session ownership.
+  * @QMI_PROTOCOL_ERROR_INSUFFICIENT_RESOURCES: Insufficient resources.
+  * @QMI_PROTOCOL_ERROR_DISABLED: Disabled.
+  * @QMI_PROTOCOL_ERROR_INVALID_OPERATION: Invalid operation.
+  * @QMI_PROTOCOL_ERROR_INVALID_QMI_COMMAND: Invalid QMI command.
+  * @QMI_PROTOCOL_ERROR_WMS_T_PDU_TYPE: WMS T-PDU type.
+  * @QMI_PROTOCOL_ERROR_WMS_SMSC_ADDRESS: WMS SMSC address.
+  * @QMI_PROTOCOL_ERROR_INFORMATION_UNAVAILABLE: Information unavailable.
+  * @QMI_PROTOCOL_ERROR_SEGMENT_TOO_LONG: Segment too long.
+  * @QMI_PROTOCOL_ERROR_SEGMENT_ORDER: Segment order.
+  * @QMI_PROTOCOL_ERROR_BUNDLING_NOT_SUPPORTED: Bundling not supported.
+  * @QMI_PROTOCOL_ERROR_POLICY_MISMATCH: Policy mismatch.
+  * @QMI_PROTOCOL_ERROR_SIM_FILE_NOT_FOUND: SIM file not found.
+  * @QMI_PROTOCOL_ERROR_EXTENDED_INTERNAL: Extended internal error.
+  * @QMI_PROTOCOL_ERROR_ACCESS_DENIED: Access denied.
+  * @QMI_PROTOCOL_ERROR_HARDWARE_RESTRICTED: Hardware restricted.
+  * @QMI_PROTOCOL_ERROR_ACK_NOT_SENT: ACK not sent.
+  * @QMI_PROTOCOL_ERROR_INJECT_TIMEOUT: Inject timeout.
+  * @QMI_PROTOCOL_ERROR_INCOMPATIBLE_STATE: Incompatible state.
+  * @QMI_PROTOCOL_ERROR_FDN_RESTRICT: FDN restrict.
+  * @QMI_PROTOCOL_ERROR_SUPS_FAILURE_CASE: SUPS failure case.
+  * @QMI_PROTOCOL_ERROR_NO_RADIO: No radio.
+  * @QMI_PROTOCOL_ERROR_NOT_SUPPORTED: Not supported.
+  * @QMI_PROTOCOL_ERROR_NO_SUBSCRIPTION: No subscription.
+  * @QMI_PROTOCOL_ERROR_CARD_CALL_CONTROL_FAILED: Card call control failed.
+  * @QMI_PROTOCOL_ERROR_NETWORK_ABORTED: Network aborted.
+  * @QMI_PROTOCOL_ERROR_MSG_BLOCKED: Message blocked.
+  * @QMI_PROTOCOL_ERROR_INVALID_SESSION_TYPE: Invalid session type.
+  * @QMI_PROTOCOL_ERROR_INVALID_PB_TYPE: Invalid PB type.
+  * @QMI_PROTOCOL_ERROR_NO_SIM: No SIM.
+  * @QMI_PROTOCOL_ERROR_PB_NOT_READY: PB not ready.
+  * @QMI_PROTOCOL_ERROR_PIN_RESTRICTION: PIN restriction.
+  * @QMI_PROTOCOL_ERROR_PIN2_RESTRICTION: PIN2 restriction.
+  * @QMI_PROTOCOL_ERROR_PUK_RESTRICTION: PUK restriction.
+  * @QMI_PROTOCOL_ERROR_PUK2_RESTRICTION: PUK2 restriction.
+  * @QMI_PROTOCOL_ERROR_PB_ACCESS_RESTRICTED: PB access restricted.
+  * @QMI_PROTOCOL_ERROR_PB_TEXT_TOO_LONG: PB text too long.
+  * @QMI_PROTOCOL_ERROR_PB_NUMBER_TOO_LONG: PB number too long.
+  * @QMI_PROTOCOL_ERROR_PB_HIDDEN_KEY_RESTRICTION: PB hidden key restriction.
+  * @QMI_PROTOCOL_ERROR_CAT_EVENT_REGISTRATION_FAILED: Event registration failed.
+  * @QMI_PROTOCOL_ERROR_CAT_INVALID_TERMINAL_RESPONSE: Invalid terminal response.
+  * @QMI_PROTOCOL_ERROR_CAT_INVALID_ENVELOPE_COMMAND: Invalid envelope command.
+  * @QMI_PROTOCOL_ERROR_CAT_ENVELOPE_COMMAND_BUSY: Envelope command busy.
+  * @QMI_PROTOCOL_ERROR_CAT_ENVELOPE_COMMAND_FAILED: Envelope command failed.
+  *
+  * QMI protocol errors.
+  */
+typedef enum { /*< underscore_name=qmi_protocol_error >*/
+  QMI_PROTOCOL_ERROR_NONE                             = 0,  /*< nick=None >*/
+  QMI_PROTOCOL_ERROR_MALFORMED_MESSAGE                = 1,  /*< nick=MalformedMessage >*/
+  QMI_PROTOCOL_ERROR_NO_MEMORY                        = 2,  /*< nick=NoMemory >*/
+  QMI_PROTOCOL_ERROR_INTERNAL                         = 3,  /*< nick=Internal >*/
+  QMI_PROTOCOL_ERROR_ABORTED                          = 4,  /*< nick=Aborted >*/
+  QMI_PROTOCOL_ERROR_CLIENT_IDS_EXHAUSTED             = 5,  /*< nick=ClientIdsExhausted >*/
+  QMI_PROTOCOL_ERROR_UNABORTABLE_TRANSACTION          = 6,  /*< nick=UnabortableTransaction >*/
+  QMI_PROTOCOL_ERROR_INVALID_CLIENT_ID                = 7,  /*< nick=InvalidClientId >*/
+  QMI_PROTOCOL_ERROR_NO_THRESHOLDS_PROVIDED           = 8,  /*< nick=NoThresholdsProvided >*/
+  QMI_PROTOCOL_ERROR_INVALID_HANDLE                   = 9,  /*< nick=InvalidHandle >*/
+  QMI_PROTOCOL_ERROR_INVALID_PROFILE                  = 10, /*< nick=InvalidProfile >*/
+  QMI_PROTOCOL_ERROR_INVALID_PIN_ID                   = 11, /*< nick=InvalidPinId >*/
+  QMI_PROTOCOL_ERROR_INCORRECT_PIN                    = 12, /*< nick=IncorrectPin >*/
+  QMI_PROTOCOL_ERROR_NO_NETWORK_FOUND                 = 13, /*< nick=NoNetworkFound >*/
+  QMI_PROTOCOL_ERROR_CALL_FAILED                      = 14, /*< nick=CallFailed >*/
+  QMI_PROTOCOL_ERROR_OUT_OF_CALL                      = 15, /*< nick=OutOfCall >*/
+  QMI_PROTOCOL_ERROR_NOT_PROVISIONED                  = 16, /*< nick=NotProvisioned >*/
+  QMI_PROTOCOL_ERROR_MISSING_ARGUMENT                 = 17, /*< nick=MissingArgument >*/
+  QMI_PROTOCOL_ERROR_ARGUMENT_TOO_LONG                = 19, /*< nick=ArgumentTooLong >*/
+  QMI_PROTOCOL_ERROR_INVALID_TRANSACTION_ID           = 22, /*< nick=InvalidTransactionId >*/
+  QMI_PROTOCOL_ERROR_DEVICE_IN_USE                    = 23, /*< nick=DeviceInUse >*/
+  QMI_PROTOCOL_ERROR_NETWORK_UNSUPPORTED              = 24, /*< nick=NetworkUnsupported >*/
+  QMI_PROTOCOL_ERROR_DEVICE_UNSUPPORTED               = 25, /*< nick=DeviceUnsupported >*/
+  QMI_PROTOCOL_ERROR_NO_EFFECT                        = 26, /*< nick=NoEffect >*/
+  QMI_PROTOCOL_ERROR_NO_FREE_PROFILE                  = 27, /*< nick=NoFreeProfile >*/
+  QMI_PROTOCOL_ERROR_INVALID_PDP_TYPE                 = 28, /*< nick=InvalidPdpType >*/
+  QMI_PROTOCOL_ERROR_INVALID_TECHNOLOGY_PREFERENCE    = 29, /*< nick=InvalidTechnologyPreference >*/
+  QMI_PROTOCOL_ERROR_INVALID_PROFILE_TYPE             = 30, /*< nick=InvalidProfileType >*/
+  QMI_PROTOCOL_ERROR_INVALID_SERVICE_TYPE             = 31, /*< nick=InvalidServiceType >*/
+  QMI_PROTOCOL_ERROR_INVALID_REGISTER_ACTION          = 32, /*< nick=InvalidRegisterAction >*/
+  QMI_PROTOCOL_ERROR_INVALID_PS_ATTACH_ACTION         = 33, /*< nick=InvalidPsAttachAction >*/
+  QMI_PROTOCOL_ERROR_AUTHENTICATION_FAILED            = 34, /*< nick=AuthenticationFailed >*/
+  QMI_PROTOCOL_ERROR_PIN_BLOCKED                      = 35, /*< nick=PinBlocked >*/
+  QMI_PROTOCOL_ERROR_PIN_ALWAYS_BLOCKED               = 36, /*< nick=PinAlwaysBlocked >*/
+  QMI_PROTOCOL_ERROR_UIM_UNINITIALIZED                = 37, /*< nick=UimUninitialized >*/
+  QMI_PROTOCOL_ERROR_MAXIMUM_QOS_REQUESTS_IN_USE      = 38, /*< nick=MaximumQosRequestsInUse >*/
+  QMI_PROTOCOL_ERROR_INCORRECT_FLOW_FILTER            = 39, /*< nick=IncorrectFlowFilter >*/
+  QMI_PROTOCOL_ERROR_NETWORK_QOS_UNAWARE              = 40, /*< nick= NetworkQosUnaware >*/
+  QMI_PROTOCOL_ERROR_INVALID_QOS_ID                   = 41, /*< nick=InvalidQosId >*/
+  QMI_PROTOCOL_ERROR_QOS_UNAVAILABLE                  = 42, /*< nick=QosUnavailable >*/
+  QMI_PROTOCOL_ERROR_FLOW_SUSPENDED                   = 43, /*< nick=FlowSuspended >*/
+  QMI_PROTOCOL_ERROR_GENERAL_ERROR                    = 46, /*< nick=GeneralError >*/
+  QMI_PROTOCOL_ERROR_UNKNOWN_ERROR                    = 47, /*< nick=UnknownError >*/
+  QMI_PROTOCOL_ERROR_INVALID_ARGUMENT                 = 48, /*< nick=InvalidArgument >*/
+  QMI_PROTOCOL_ERROR_INVALID_INDEX                    = 49, /*< nick=InvalidIndex >*/
+  QMI_PROTOCOL_ERROR_NO_ENTRY                         = 50, /*< nick=NoEntry >*/
+  QMI_PROTOCOL_ERROR_DEVICE_STORAGE_FULL              = 51, /*< nick=DeviceStorageFull >*/
+  QMI_PROTOCOL_ERROR_DEVICE_NOT_READY                 = 52, /*< nick=DeviceNotReady >*/
+  QMI_PROTOCOL_ERROR_NETWORK_NOT_READY                = 53, /*< nick=NetworkNotReady >*/
+  QMI_PROTOCOL_ERROR_WMS_CAUSE_CODE                   = 54, /*< nick=Wms.CauseCode >*/
+  QMI_PROTOCOL_ERROR_WMS_MESSAGE_NOT_SENT             = 55, /*< nick=Wms.MessageNotSent >*/
+  QMI_PROTOCOL_ERROR_WMS_MESSAGE_DELIVERY_FAILURE     = 56, /*< nick=Wms.MessageDeliveryFailure >*/
+  QMI_PROTOCOL_ERROR_WMS_INVALID_MESSAGE_ID           = 57, /*< nick=Wms.InvalidMessageId >*/
+  QMI_PROTOCOL_ERROR_WMS_ENCODING                     = 58, /*< nick=Wms.Encoding >*/
+  QMI_PROTOCOL_ERROR_AUTHENTICATION_LOCK              = 59, /*< nick=AuthenticationLock >*/
+  QMI_PROTOCOL_ERROR_INVALID_TRANSITION               = 60, /*< nick=InvalidTransaction >*/
+  QMI_PROTOCOL_ERROR_SESSION_INACTIVE                 = 65, /*< nick=SessionInactive >*/
+  QMI_PROTOCOL_ERROR_SESSION_INVALID                  = 66, /*< nick=SessionInvalid >*/
+  QMI_PROTOCOL_ERROR_SESSION_OWNERSHIP                = 67, /*< nick=SessionOwnership >*/
+  QMI_PROTOCOL_ERROR_INSUFFICIENT_RESOURCES           = 68, /*< nick=InsufficientResources >*/
+  QMI_PROTOCOL_ERROR_DISABLED                         = 69, /*< nick=Disabled >*/
+  QMI_PROTOCOL_ERROR_INVALID_OPERATION                = 70, /*< nick=InvalidOperation >*/
+  QMI_PROTOCOL_ERROR_INVALID_QMI_COMMAND              = 71, /*< nick=InvalidQmiCommand >*/
+  QMI_PROTOCOL_ERROR_WMS_T_PDU_TYPE                   = 72, /*< nick=Wms.TPduType >*/
+  QMI_PROTOCOL_ERROR_WMS_SMSC_ADDRESS                 = 73, /*< nick=Wms.SmscAddress >*/
+  QMI_PROTOCOL_ERROR_INFORMATION_UNAVAILABLE          = 74, /*< nick=InformationUnavailable >*/
+  QMI_PROTOCOL_ERROR_SEGMENT_TOO_LONG                 = 75, /*< nick=SegmentTooLong >*/
+  QMI_PROTOCOL_ERROR_SEGMENT_ORDER                    = 76, /*< nick=SegmentOrder >*/
+  QMI_PROTOCOL_ERROR_BUNDLING_NOT_SUPPORTED           = 77, /*< nick=BundlingNotSupported >*/
+  /* 0x004E, 78: unused */
+  QMI_PROTOCOL_ERROR_POLICY_MISMATCH                  = 79, /*< nick=PolicyMismatch >*/
+  QMI_PROTOCOL_ERROR_SIM_FILE_NOT_FOUND               = 80, /*< nick=SimFileNotFound >*/
+  QMI_PROTOCOL_ERROR_EXTENDED_INTERNAL                = 81, /*< nick=ExtendedInternal >*/
+  QMI_PROTOCOL_ERROR_ACCESS_DENIED                    = 82, /*< nick=AccessDenied >*/
+  QMI_PROTOCOL_ERROR_HARDWARE_RESTRICTED              = 83, /*< nick=HardwareRestricted >*/
+  QMI_PROTOCOL_ERROR_ACK_NOT_SENT                     = 84, /*< nick=AckNotSent >*/
+  QMI_PROTOCOL_ERROR_INJECT_TIMEOUT                   = 85, /*< nick=InjectTimeout >*/
+  QMI_PROTOCOL_ERROR_INCOMPATIBLE_STATE               = 90, /*< nick=IncompatibleState >*/
+  QMI_PROTOCOL_ERROR_FDN_RESTRICT                     = 91, /*< nick=FdnRestrict >*/
+  QMI_PROTOCOL_ERROR_SUPS_FAILURE_CASE                = 92, /*< nick=SupsFailureCase >*/
+  QMI_PROTOCOL_ERROR_NO_RADIO                         = 93, /*< nick=NoRadio >*/
+  QMI_PROTOCOL_ERROR_NOT_SUPPORTED                    = 94, /*< nick=NotSupported >*/
+  QMI_PROTOCOL_ERROR_NO_SUBSCRIPTION                  = 95, /*< nick=NoSubscription >*/
+  QMI_PROTOCOL_ERROR_CARD_CALL_CONTROL_FAILED         = 96, /*< nick=CardCallControlFailed >*/
+  QMI_PROTOCOL_ERROR_NETWORK_ABORTED                  = 97, /*< nick=NetworkAborted >*/
+  QMI_PROTOCOL_ERROR_MSG_BLOCKED                      = 98, /*< nick=MsgBlocked >*/
+  QMI_PROTOCOL_ERROR_INVALID_SESSION_TYPE             = 100, /*< nick=InvalidSessionType >*/
+  QMI_PROTOCOL_ERROR_INVALID_PB_TYPE                  = 101, /*< nick=InvalidPbType >*/
+  QMI_PROTOCOL_ERROR_NO_SIM                           = 102, /*< nick=NoSim >*/
+  QMI_PROTOCOL_ERROR_PB_NOT_READY                     = 103, /*< nick=PbNotReady >*/
+  QMI_PROTOCOL_ERROR_PIN_RESTRICTION                  = 104, /*< nick=PinRestriction >*/
+  QMI_PROTOCOL_ERROR_PIN2_RESTRICTION                 = 105, /*< nick=Pin1Restriction >*/
+  QMI_PROTOCOL_ERROR_PUK_RESTRICTION                  = 106, /*< nick=PukRestriction >*/
+  QMI_PROTOCOL_ERROR_PUK2_RESTRICTION                 = 107, /*< nick=Puk2Restriction >*/
+  QMI_PROTOCOL_ERROR_PB_ACCESS_RESTRICTED             = 108, /*< nick=PbAccessRestricted >*/
+  QMI_PROTOCOL_ERROR_PB_TEXT_TOO_LONG                 = 109, /*< nick=PbTextTooLong >*/
+  QMI_PROTOCOL_ERROR_PB_NUMBER_TOO_LONG               = 110, /*< nick=PbNumberTooLong >*/
+  QMI_PROTOCOL_ERROR_PB_HIDDEN_KEY_RESTRICTION        = 111, /*< nick=PbHiddenKeyRestriction >*/
+  QMI_PROTOCOL_ERROR_CAT_EVENT_REGISTRATION_FAILED    = 61441, /*< nick=Cat.EventRegistrationFailed >*/
+  QMI_PROTOCOL_ERROR_CAT_INVALID_TERMINAL_RESPONSE    = 61442, /*< nick=Cat.InvalidTerminalResponse >*/
+  QMI_PROTOCOL_ERROR_CAT_INVALID_ENVELOPE_COMMAND     = 61443, /*< nick=Cat.InvalidEnvelopeCommand >*/
+  QMI_PROTOCOL_ERROR_CAT_ENVELOPE_COMMAND_BUSY        = 61444, /*< nick=Cat.EnvelopCommandBusy >*/
+  QMI_PROTOCOL_ERROR_CAT_ENVELOPE_COMMAND_FAILED      = 61445  /*< nick=Cat.EnvelopeCommandFailed >*/
+} QmiProtocolError;
+
+#endif /* _LIBQMI_GLIB_QMI_ERRORS_H_ */
diff --git a/src/libqmi-glib/qmi-flags64-dms.h b/src/libqmi-glib/qmi-flags64-dms.h
new file mode 100644
index 0000000..23dd67c
--- /dev/null
+++ b/src/libqmi-glib/qmi-flags64-dms.h
@@ -0,0 +1,204 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Lanedo GmbH <aleksander@lanedo.com>
+ * Copyright (C) 2012 Google, Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_FLAGS64_DMS_H_
+#define _LIBQMI_GLIB_QMI_FLAGS64_DMS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+#include <glib.h>
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI DMS Get Band Capability' message */
+
+/**
+ * QmiDmsBandCapability:
+ * @QMI_DMS_BAND_CAPABILITY_BC_0_A_SYSTEM: Band class 0, A-system.
+ * @QMI_DMS_BAND_CAPABILITY_BC_0_B_SYSTEM: Band class 0, B-system.
+ * @QMI_DMS_BAND_CAPABILITY_BC_1_ALL_BLOCKS: Band class 1, all blocks.
+ * @QMI_DMS_BAND_CAPABILITY_BC_2: Band class 2.
+ * @QMI_DMS_BAND_CAPABILITY_BC_3_A_SYSTEM: Band class 3, A-system.
+ * @QMI_DMS_BAND_CAPABILITY_BC_4_ALL_BLOCKS: Band class 4, all blocks.
+ * @QMI_DMS_BAND_CAPABILITY_BC_5_ALL_BLOCKS: Band class 5, all blocks.
+ * @QMI_DMS_BAND_CAPABILITY_BC_6: Band class 6.
+ * @QMI_DMS_BAND_CAPABILITY_BC_7: Band class 7.
+ * @QMI_DMS_BAND_CAPABILITY_BC_8: Band class 8.
+ * @QMI_DMS_BAND_CAPABILITY_BC_9: Band class 9.
+ * @QMI_DMS_BAND_CAPABILITY_BC_10: Band class 10.
+ * @QMI_DMS_BAND_CAPABILITY_BC_11: Band class 11.
+ * @QMI_DMS_BAND_CAPABILITY_BC_12: Band class 12.
+ * @QMI_DMS_BAND_CAPABILITY_BC_14: Band class 14.
+ * @QMI_DMS_BAND_CAPABILITY_BC_15: Band class 15.
+ * @QMI_DMS_BAND_CAPABILITY_BC_16: Band class 16.
+ * @QMI_DMS_BAND_CAPABILITY_BC_17: Band class 17.
+ * @QMI_DMS_BAND_CAPABILITY_BC_18: Band class 18.
+ * @QMI_DMS_BAND_CAPABILITY_BC_19: Band class 19.
+ * @QMI_DMS_BAND_CAPABILITY_GSM_DCS_1800: GSM DCS band.
+ * @QMI_DMS_BAND_CAPABILITY_GSM_900_EXTENDED: GSM Extended GSM band (900).
+ * @QMI_DMS_BAND_CAPABILITY_GSM_900_PRIMARY: GSM Primary GSM band (900).
+ * @QMI_DMS_BAND_CAPABILITY_GSM_450: GSM 450 band.
+ * @QMI_DMS_BAND_CAPABILITY_GSM_480: GSM 480 band.
+ * @QMI_DMS_BAND_CAPABILITY_GSM_750: GSM 750 band.
+ * @QMI_DMS_BAND_CAPABILITY_GSM_850: GSM 850 band.
+ * @QMI_DMS_BAND_CAPABILITY_GSM_900_RAILWAYS: GSM railways band (900).
+ * @QMI_DMS_BAND_CAPABILITY_GSM_PCS_1900: GSM PCS band (1900).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_2100: WCDMA 2100 band (Europe, Japan, China).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_PCS_1900: WCDMA PCS 1900 band (US).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_DCS_1800: WCDMA DCS 1800 band (Europe, China).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_1700_US: WCDMA 1700 band (US).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_850_US: WCDMA 850 band (US).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_800: QWCDMA 850 band (Japan).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_2600: WCDMA 2600 band (Europe).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_900: WCDMA 900 band (Europe, Japan).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_1700_JAPAN: WCDMA 1700 band (Japan).
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_850_JAPAN: WCDMA 850 band (Japan)
+ * @QMI_DMS_BAND_CAPABILITY_WCDMA_1500: WCDMA 1500 band.
+ *
+ * Frequency band capabilities.
+ */
+typedef enum {
+    QMI_DMS_BAND_CAPABILITY_BC_0_A_SYSTEM    = 1 << 0,
+    QMI_DMS_BAND_CAPABILITY_BC_0_B_SYSTEM    = 1 << 1,
+    QMI_DMS_BAND_CAPABILITY_BC_1_ALL_BLOCKS  = 1 << 2,
+    QMI_DMS_BAND_CAPABILITY_BC_2             = 1 << 3,
+    QMI_DMS_BAND_CAPABILITY_BC_3_A_SYSTEM    = 1 << 4,
+    QMI_DMS_BAND_CAPABILITY_BC_4_ALL_BLOCKS  = 1 << 5,
+    QMI_DMS_BAND_CAPABILITY_BC_5_ALL_BLOCKS  = 1 << 6,
+    QMI_DMS_BAND_CAPABILITY_GSM_DCS_1800     = 1 << 7,
+    QMI_DMS_BAND_CAPABILITY_GSM_900_EXTENDED = 1 << 8,
+    QMI_DMS_BAND_CAPABILITY_GSM_900_PRIMARY  = 1 << 9,
+    QMI_DMS_BAND_CAPABILITY_BC_6             = 1 << 10,
+    QMI_DMS_BAND_CAPABILITY_BC_7             = 1 << 11,
+    QMI_DMS_BAND_CAPABILITY_BC_8             = 1 << 12,
+    QMI_DMS_BAND_CAPABILITY_BC_9             = 1 << 13,
+    QMI_DMS_BAND_CAPABILITY_BC_10            = 1 << 14,
+    QMI_DMS_BAND_CAPABILITY_BC_11            = 1 << 15,
+    QMI_DMS_BAND_CAPABILITY_GSM_450          = 1 << 16,
+    QMI_DMS_BAND_CAPABILITY_GSM_480          = 1 << 17,
+    QMI_DMS_BAND_CAPABILITY_GSM_750          = 1 << 18,
+    QMI_DMS_BAND_CAPABILITY_GSM_850          = 1 << 19,
+    QMI_DMS_BAND_CAPABILITY_GSM_900_RAILWAYS = 1 << 20,
+    QMI_DMS_BAND_CAPABILITY_GSM_PCS_1900     = 1 << 21,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_2100       = 1 << 22,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_PCS_1900   = 1 << 23,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_DCS_1800   = 1 << 24,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_1700_US    = 1 << 25,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_850_US     = 1 << 26,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_800        = 1 << 27,
+    QMI_DMS_BAND_CAPABILITY_BC_12            = 1 << 28,
+    QMI_DMS_BAND_CAPABILITY_BC_14            = 1 << 29,
+    /* Bit 30 reserved */
+    QMI_DMS_BAND_CAPABILITY_BC_15            = 1 << 31,
+    /* Bits 32-47 reserved */
+    QMI_DMS_BAND_CAPABILITY_WCDMA_2600       = ((guint64) 1) << 48,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_900        = ((guint64) 1) << 49,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_1700_JAPAN = ((guint64) 1) << 50,
+    /* Bits 51-55 reserved */
+    QMI_DMS_BAND_CAPABILITY_BC_16            = ((guint64) 1) << 56,
+    QMI_DMS_BAND_CAPABILITY_BC_17            = ((guint64) 1) << 57,
+    QMI_DMS_BAND_CAPABILITY_BC_18            = ((guint64) 1) << 58,
+    QMI_DMS_BAND_CAPABILITY_BC_19            = ((guint64) 1) << 59,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_850_JAPAN  = ((guint64) 1) << 60,
+    QMI_DMS_BAND_CAPABILITY_WCDMA_1500       = ((guint64) 1) << 61
+    /* Bits 62-63 reserved */
+} QmiDmsBandCapability;
+
+/**
+ * QmiDmsLteBandCapability:
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_1: LTE EUTRAN Band 1
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_2: LTE EUTRAN Band 2.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_3: LTE EUTRAN Band 3.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_4: LTE EUTRAN Band 4.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_5: LTE EUTRAN Band 5.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_6: LTE EUTRAN Band 6.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_7: LTE EUTRAN Band 7.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_8: LTE EUTRAN Band 8.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_9: LTE EUTRAN Band 9.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_10: LTE EUTRAN Band 10.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_11: LTE EUTRAN Band 11.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_12: LTE EUTRAN Band 12.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_13: LTE EUTRAN Band 13.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_14: LTE EUTRAN Band 14.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_17: LTE EUTRAN Band 17.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_18: LTE EUTRAN Band 18.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_19: LTE EUTRAN Band 19.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_20: LTE EUTRAN Band 20.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_21: LTE EUTRAN Band 21.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_24: LTE EUTRAN Band 24.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_25: LTE EUTRAN Band 25.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_33: LTE EUTRAN Band 33.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_34: LTE EUTRAN Band 34.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_35: LTE EUTRAN Band 35.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_36: LTE EUTRAN Band 36.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_37: LTE EUTRAN Band 37.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_38: LTE EUTRAN Band 38.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_39: LTE EUTRAN Band 39.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_40: LTE EUTRAN Band 40.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_41: LTE EUTRAN Band 41.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_42: LTE EUTRAN Band 42.
+ * @QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_43: LTE EUTRAN Band 43.
+ *
+ * LTE-specific Frequency bands.
+ */
+typedef enum {
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_1  = 1 << 0,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_2  = 1 << 1,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_3  = 1 << 2,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_4  = 1 << 3,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_5  = 1 << 4,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_6  = 1 << 5,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_7  = 1 << 6,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_8  = 1 << 7,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_9  = 1 << 8,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_10 = 1 << 9,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_11 = 1 << 10,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_12 = 1 << 11,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_13 = 1 << 12,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_14 = 1 << 13,
+    /* Bit 14-15 reserved */
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_17 = 1 << 16,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_18 = 1 << 17,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_19 = 1 << 18,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_20 = 1 << 19,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_21 = 1 << 20,
+    /* Bit 21-22 reserved */
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_24 = 1 << 23,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_25 = 1 << 24,
+    /* Bit 25-31 reserved */
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_33 = ((guint64) 1) << 32,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_34 = ((guint64) 1) << 33,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_35 = ((guint64) 1) << 34,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_36 = ((guint64) 1) << 35,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_37 = ((guint64) 1) << 36,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_38 = ((guint64) 1) << 37,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_39 = ((guint64) 1) << 38,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_40 = ((guint64) 1) << 39,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_41 = ((guint64) 1) << 40,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_42 = ((guint64) 1) << 41,
+    QMI_DMS_LTE_BAND_CAPABILITY_EUTRAN_43 = ((guint64) 1) << 42
+    /* Bit 43-64 reserved */
+} QmiDmsLteBandCapability;
+
+#endif /* _LIBQMI_GLIB_QMI_FLAGS64_DMS_H_ */
diff --git a/src/libqmi-glib/qmi-flags64-nas.h b/src/libqmi-glib/qmi-flags64-nas.h
new file mode 100644
index 0000000..b76f8f2
--- /dev/null
+++ b/src/libqmi-glib/qmi-flags64-nas.h
@@ -0,0 +1,200 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Google Inc.
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_FLAGS64_NAS_H_
+#define _LIBQMI_GLIB_QMI_FLAGS64_NAS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+#include <glib.h>
+
+/*****************************************************************************/
+/* Helper enums for the 'QMI NAS Get System Selection Preference'
+ * request/response */
+
+/**
+ * QmiNasBandPreference:
+ * @QMI_NAS_BAND_PREFERENCE_BC_0_A_SYSTEM: Band class 0, A system.
+ * @QMI_NAS_BAND_PREFERENCE_BC_0_B_SYSTEM: Band class 0, B system.
+ * @QMI_NAS_BAND_PREFERENCE_BC_1_ALL_BLOCKS: Band class 1.
+ * @QMI_NAS_BAND_PREFERENCE_BC_2: Band class 2.
+ * @QMI_NAS_BAND_PREFERENCE_BC_3_A_SYSTEM: Band class 3, A system.
+ * @QMI_NAS_BAND_PREFERENCE_BC_4_ALL_BLOCKS: Band class 4, all blocks.
+ * @QMI_NAS_BAND_PREFERENCE_BC_5_ALL_BLOCKS: Band class 5, all blocks.
+ * @QMI_NAS_BAND_PREFERENCE_BC_6: Band class 6.
+ * @QMI_NAS_BAND_PREFERENCE_BC_7: Band class 7.
+ * @QMI_NAS_BAND_PREFERENCE_BC_8: Band class 8.
+ * @QMI_NAS_BAND_PREFERENCE_BC_9: Band class 9.
+ * @QMI_NAS_BAND_PREFERENCE_BC_10: Band class 10.
+ * @QMI_NAS_BAND_PREFERENCE_BC_11: Band class 11.
+ * @QMI_NAS_BAND_PREFERENCE_BC_12: Band class 12.
+ * @QMI_NAS_BAND_PREFERENCE_BC_14: Band class 14.
+ * @QMI_NAS_BAND_PREFERENCE_BC_15: Band class 15.
+ * @QMI_NAS_BAND_PREFERENCE_BC_16: Band class 16.
+ * @QMI_NAS_BAND_PREFERENCE_BC_17: Band class 17.
+ * @QMI_NAS_BAND_PREFERENCE_BC_18: Band class 18.
+ * @QMI_NAS_BAND_PREFERENCE_BC_19: Band class 19.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_DCS_1800: GSM DCS 1800 band.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_900_EXTENDED: Extended GSM 900 band.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_900_PRIMARY: Primary GSM 900 band.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_450: GSM 450.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_480: GSM 480.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_750: GSM 750.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_850: GSM 850.
+ * @QMI_NAS_BAND_PREFERENCE_GSM_900_RAILWAYS: GSM 900 (Railways).
+ * @QMI_NAS_BAND_PREFERENCE_GSM_PCS_1900: GSM 1900.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_2100: WCDMA 2100.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_PCS_1900: WCDMA PCS 1900.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_DCS_1800: WCDMA DCS 1800.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_1700_US: WCDMA 1700 (U.S.).
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_850_US: WCDMA 850.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_800: WCDMA 800.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_2600: WCDMA 2600.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_900: WCDMA 900.
+ * @QMI_NAS_BAND_PREFERENCE_WCDMA_1700_JAPAN: WCDMA 1700 (Japan).
+ *
+ * Flags to specify frequency band preferences.
+ */
+typedef enum {
+    QMI_NAS_BAND_PREFERENCE_BC_0_A_SYSTEM    = 1 << 0,
+    QMI_NAS_BAND_PREFERENCE_BC_0_B_SYSTEM    = 1 << 1,
+    QMI_NAS_BAND_PREFERENCE_BC_1_ALL_BLOCKS  = 1 << 2,
+    QMI_NAS_BAND_PREFERENCE_BC_2             = 1 << 3,
+    QMI_NAS_BAND_PREFERENCE_BC_3_A_SYSTEM    = 1 << 4,
+    QMI_NAS_BAND_PREFERENCE_BC_4_ALL_BLOCKS  = 1 << 5,
+    QMI_NAS_BAND_PREFERENCE_BC_5_ALL_BLOCKS  = 1 << 6,
+    QMI_NAS_BAND_PREFERENCE_GSM_DCS_1800     = 1 << 7,
+    QMI_NAS_BAND_PREFERENCE_GSM_900_EXTENDED = 1 << 8,
+    QMI_NAS_BAND_PREFERENCE_GSM_900_PRIMARY  = 1 << 9,
+    QMI_NAS_BAND_PREFERENCE_BC_6             = 1 << 10,
+    QMI_NAS_BAND_PREFERENCE_BC_7             = 1 << 11,
+    QMI_NAS_BAND_PREFERENCE_BC_8             = 1 << 12,
+    QMI_NAS_BAND_PREFERENCE_BC_9             = 1 << 13,
+    QMI_NAS_BAND_PREFERENCE_BC_10            = 1 << 14,
+    QMI_NAS_BAND_PREFERENCE_BC_11            = 1 << 15,
+    QMI_NAS_BAND_PREFERENCE_GSM_450          = 1 << 16,
+    QMI_NAS_BAND_PREFERENCE_GSM_480          = 1 << 17,
+    QMI_NAS_BAND_PREFERENCE_GSM_750          = 1 << 18,
+    QMI_NAS_BAND_PREFERENCE_GSM_850          = 1 << 19,
+    QMI_NAS_BAND_PREFERENCE_GSM_900_RAILWAYS = 1 << 20,
+    QMI_NAS_BAND_PREFERENCE_GSM_PCS_1900     = 1 << 21,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_2100       = 1 << 22,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_PCS_1900   = 1 << 23,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_DCS_1800   = 1 << 24,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_1700_US    = 1 << 25,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_850_US     = 1 << 26,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_800        = 1 << 27,
+    QMI_NAS_BAND_PREFERENCE_BC_12            = 1 << 28,
+    QMI_NAS_BAND_PREFERENCE_BC_14            = 1 << 29,
+    /* Bit 30 reserved */
+    QMI_NAS_BAND_PREFERENCE_BC_15            = 1 << 31,
+    /* Bits 32-47 reserved */
+    QMI_NAS_BAND_PREFERENCE_WCDMA_2600       = ((guint64) 1) << 48,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_900        = ((guint64) 1) << 49,
+    QMI_NAS_BAND_PREFERENCE_WCDMA_1700_JAPAN = ((guint64) 1) << 50,
+    /* Bits 51-55 reserved */
+    QMI_NAS_BAND_PREFERENCE_BC_16            = ((guint64) 1) << 56,
+    QMI_NAS_BAND_PREFERENCE_BC_17            = ((guint64) 1) << 57,
+    QMI_NAS_BAND_PREFERENCE_BC_18            = ((guint64) 1) << 58,
+    QMI_NAS_BAND_PREFERENCE_BC_19            = ((guint64) 1) << 59
+    /* Bits 60-63 reserved */
+} QmiNasBandPreference;
+
+/**
+ * QmiNasLteBandPreference:
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_1: LTE EUTRAN Band 1
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_2: LTE EUTRAN Band 2.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_3: LTE EUTRAN Band 3.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_4: LTE EUTRAN Band 4.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_5: LTE EUTRAN Band 5.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_6: LTE EUTRAN Band 6.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_7: LTE EUTRAN Band 7.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_8: LTE EUTRAN Band 8.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_9: LTE EUTRAN Band 9.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_10: LTE EUTRAN Band 10.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_11: LTE EUTRAN Band 11.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_12: LTE EUTRAN Band 12.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_13: LTE EUTRAN Band 13.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_14: LTE EUTRAN Band 14.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_17: LTE EUTRAN Band 17.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_18: LTE EUTRAN Band 18.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_19: LTE EUTRAN Band 19.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_20: LTE EUTRAN Band 20.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_21: LTE EUTRAN Band 21.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_24: LTE EUTRAN Band 24.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_25: LTE EUTRAN Band 25.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_33: LTE EUTRAN Band 33.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_34: LTE EUTRAN Band 34.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_35: LTE EUTRAN Band 35.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_36: LTE EUTRAN Band 36.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_37: LTE EUTRAN Band 37.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_38: LTE EUTRAN Band 38.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_39: LTE EUTRAN Band 39.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_40: LTE EUTRAN Band 40.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_41: LTE EUTRAN Band 41.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_42: LTE EUTRAN Band 42.
+ * @QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_43: LTE EUTRAN Band 43.
+ *
+ * Flags to specify LTE-specific frequency band preferences.
+ */
+typedef enum {
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_1  = 1 << 0,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_2  = 1 << 1,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_3  = 1 << 2,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_4  = 1 << 3,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_5  = 1 << 4,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_6  = 1 << 5,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_7  = 1 << 6,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_8  = 1 << 7,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_9  = 1 << 8,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_10 = 1 << 9,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_11 = 1 << 10,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_12 = 1 << 11,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_13 = 1 << 12,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_14 = 1 << 13,
+    /* Bit 14-15 reserved */
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_17 = 1 << 16,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_18 = 1 << 17,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_19 = 1 << 18,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_20 = 1 << 19,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_21 = 1 << 20,
+    /* Bit 21-22 reserved */
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_24 = 1 << 23,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_25 = 1 << 24,
+    /* Bit 25-31 reserved */
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_33 = ((guint64) 1) << 32,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_34 = ((guint64) 1) << 33,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_35 = ((guint64) 1) << 34,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_36 = ((guint64) 1) << 35,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_37 = ((guint64) 1) << 36,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_38 = ((guint64) 1) << 37,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_39 = ((guint64) 1) << 38,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_40 = ((guint64) 1) << 39,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_41 = ((guint64) 1) << 40,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_42 = ((guint64) 1) << 41,
+    QMI_NAS_LTE_BAND_PREFERENCE_EUTRAN_43 = ((guint64) 1) << 42
+    /* Bit 43-64 reserved */
+} QmiNasLteBandPreference;
+
+#endif /* _LIBQMI_GLIB_QMI_FLAGS64_NAS_H_ */
diff --git a/src/libqmi-glib/qmi-message.c b/src/libqmi-glib/qmi-message.c
new file mode 100644
index 0000000..c3bd6e0
--- /dev/null
+++ b/src/libqmi-glib/qmi-message.c
@@ -0,0 +1,923 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ * Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file of the libqmi library.
+ */
+
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#include <glib.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <endian.h>
+
+#include "qmi-message.h"
+#include "qmi-utils.h"
+#include "qmi-enums-private.h"
+#include "qmi-enum-types-private.h"
+#include "qmi-enum-types.h"
+#include "qmi-error-types.h"
+
+#include "qmi-ctl.h"
+#include "qmi-dms.h"
+#include "qmi-wds.h"
+#include "qmi-nas.h"
+#include "qmi-wms.h"
+#include "qmi-pds.h"
+#include "qmi-uim.h"
+
+/**
+ * SECTION:qmi-message
+ * @title: QmiMessage
+ * @short_description: Generic QMI message handling routines
+ *
+ * #QmiMessage is a generic type representing a QMI message of any kind
+ * (request, response, indication) or service (including #QMI_SERVICE_CTL).
+ *
+ * This set of generic routines help in handling these message types, and
+ * allow creating any kind of message with any kind of TLV.
+ **/
+
+#define PACKED __attribute__((packed))
+
+struct qmux {
+  guint16 length;
+  guint8 flags;
+  guint8 service;
+  guint8 client;
+} PACKED;
+
+struct control_header {
+  guint8 flags;
+  guint8 transaction;
+  guint16 message;
+  guint16 tlv_length;
+} PACKED;
+
+struct service_header {
+  guint8 flags;
+  guint16 transaction;
+  guint16 message;
+  guint16 tlv_length;
+} PACKED;
+
+struct tlv {
+  guint8 type;
+  guint16 length;
+  guint8 value[];
+} PACKED;
+
+struct control_message {
+  struct control_header header;
+  struct tlv tlv[];
+} PACKED;
+
+struct service_message {
+  struct service_header header;
+  struct tlv tlv[];
+} PACKED;
+
+struct full_message {
+    guint8 marker;
+    struct qmux qmux;
+    union {
+        struct control_message control;
+        struct service_message service;
+    } qmi;
+} PACKED;
+
+static inline gboolean
+message_is_control (QmiMessage *self)
+{
+    return ((struct full_message *)(self->data))->qmux.service == QMI_SERVICE_CTL;
+}
+
+static inline guint16
+get_qmux_length (QmiMessage *self)
+{
+    return GUINT16_FROM_LE (((struct full_message *)(self->data))->qmux.length);
+}
+
+static inline void
+set_qmux_length (QmiMessage *self,
+                 guint16 length)
+{
+    ((struct full_message *)(self->data))->qmux.length = GUINT16_TO_LE (length);
+}
+
+static inline guint8
+get_qmux_flags (QmiMessage *self)
+{
+    return ((struct full_message *)(self->data))->qmux.flags;
+}
+
+static inline guint8
+get_qmi_flags (QmiMessage *self)
+{
+    if (message_is_control (self))
+        return ((struct full_message *)(self->data))->qmi.control.header.flags;
+
+    return ((struct full_message *)(self->data))->qmi.service.header.flags;
+}
+
+/**
+ * qmi_message_is_response:
+ * @self: a #QmiMessage.
+ *
+ * Checks whether the given #QmiMessage is a response.
+ *
+ * Returns: %TRUE if @self is a response message, %FALSE otherwise.
+ */
+gboolean
+qmi_message_is_response (QmiMessage *self)
+{
+    if (message_is_control (self)) {
+        if (((struct full_message *)(self->data))->qmi.control.header.flags & QMI_CTL_FLAG_RESPONSE)
+            return TRUE;
+    } else {
+        if (((struct full_message *)(self->data))->qmi.service.header.flags & QMI_SERVICE_FLAG_RESPONSE)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+/**
+ * qmi_message_is_indication:
+ * @self: a #QmiMessage.
+ *
+ * Checks whether the given #QmiMessage is an indication.
+ *
+ * Returns: %TRUE if @self is an indication message, %FALSE otherwise.
+ */
+gboolean
+qmi_message_is_indication (QmiMessage *self)
+{
+    if (message_is_control (self)) {
+        if (((struct full_message *)(self->data))->qmi.control.header.flags & QMI_CTL_FLAG_INDICATION)
+            return TRUE;
+    } else {
+        if (((struct full_message *)(self->data))->qmi.service.header.flags & QMI_SERVICE_FLAG_INDICATION)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+/**
+ * qmi_message_get_service:
+ * @self: a #QmiMessage.
+ *
+ * Gets the service corresponding to the given #QmiMessage.
+ *
+ * Returns: a #QmiService.
+ */
+QmiService
+qmi_message_get_service (QmiMessage *self)
+{
+    g_return_val_if_fail (self != NULL, QMI_SERVICE_UNKNOWN);
+
+    return (QmiService)((struct full_message *)(self->data))->qmux.service;
+}
+
+/**
+ * qmi_message_get_client_id:
+ * @self: a #QmiMessage.
+ *
+ * Gets the client ID of the message.
+ *
+ * Returns: the client ID.
+ */
+guint8
+qmi_message_get_client_id (QmiMessage *self)
+{
+    g_return_val_if_fail (self != NULL, 0);
+
+    return ((struct full_message *)(self->data))->qmux.client;
+}
+
+/**
+ * qmi_message_get_transaction_id:
+ * @self: a #QmiMessage.
+ *
+ * Gets the transaction ID of the message.
+ *
+ * Returns: the transaction ID.
+ */
+guint16
+qmi_message_get_transaction_id (QmiMessage *self)
+{
+    g_return_val_if_fail (self != NULL, 0);
+
+    if (message_is_control (self))
+        /* note: only 1 byte for transaction in CTL message */
+        return (guint16)((struct full_message *)(self->data))->qmi.control.header.transaction;
+
+    return GUINT16_FROM_LE (((struct full_message *)(self->data))->qmi.service.header.transaction);
+}
+
+/**
+ * qmi_message_get_message_id:
+ * @self: a #QmiMessage.
+ *
+ * Gets the ID of the message.
+ *
+ * Returns: the ID.
+ */
+guint16
+qmi_message_get_message_id (QmiMessage *self)
+{
+    g_return_val_if_fail (self != NULL, 0);
+
+    if (message_is_control (self))
+        return GUINT16_FROM_LE (((struct full_message *)(self->data))->qmi.control.header.message);
+
+    return GUINT16_FROM_LE (((struct full_message *)(self->data))->qmi.service.header.message);
+}
+
+/**
+ * qmi_message_get_length:
+ * @self: a #QmiMessage.
+ *
+ * Gets the length of the raw data corresponding to the given #QmiMessage.
+ *
+ * Returns: the length of the raw data.
+ */
+gsize
+qmi_message_get_length (QmiMessage *self)
+{
+    g_return_val_if_fail (self != NULL, 0);
+
+    return self->len;
+}
+
+static inline guint16
+get_all_tlvs_length (QmiMessage *self)
+{
+    if (message_is_control (self))
+        return GUINT16_FROM_LE (((struct full_message *)(self->data))->qmi.control.header.tlv_length);
+
+    return GUINT16_FROM_LE (((struct full_message *)(self->data))->qmi.service.header.tlv_length);
+}
+
+static inline void
+set_all_tlvs_length (QmiMessage *self,
+                     guint16 length)
+{
+    if (message_is_control (self))
+        ((struct full_message *)(self->data))->qmi.control.header.tlv_length = GUINT16_TO_LE (length);
+    else
+        ((struct full_message *)(self->data))->qmi.service.header.tlv_length = GUINT16_TO_LE (length);
+}
+
+static inline struct tlv *
+qmi_tlv (QmiMessage *self)
+{
+    if (message_is_control (self))
+        return ((struct full_message *)(self->data))->qmi.control.tlv;
+
+    return ((struct full_message *)(self->data))->qmi.service.tlv;
+}
+
+static inline guint8 *
+qmi_end (QmiMessage *self)
+{
+    return (guint8 *) self->data + self->len;
+}
+
+static inline struct tlv *
+tlv_next (struct tlv *tlv)
+{
+    return (struct tlv *)((guint8 *)tlv + sizeof(struct tlv) + GUINT16_FROM_LE (tlv->length));
+}
+
+static inline struct tlv *
+qmi_tlv_first (QmiMessage *self)
+{
+    if (get_all_tlvs_length (self))
+        return qmi_tlv (self);
+
+    return NULL;
+}
+
+static inline struct tlv *
+qmi_tlv_next (QmiMessage *self,
+              struct tlv *tlv)
+{
+    struct tlv *end;
+    struct tlv *next;
+
+    end = (struct tlv *) qmi_end (self);
+    next = tlv_next (tlv);
+
+    return (next < end ? next : NULL);
+}
+
+/*
+ * Checks the validity of a QMI message.
+ *
+ * In particular, checks:
+ * 1. The message has space for all required headers.
+ * 2. The length of the buffer, the qmux length field, and the QMI tlv_length
+ *    field are all consistent.
+ * 3. The TLVs in the message fit exactly in the payload size.
+ *
+ * Returns: %TRUE if the message is valid, %FALSE otherwise.
+ */
+static gboolean
+message_check (QmiMessage *self,
+               GError **error)
+{
+    gsize header_length;
+    guint8 *end;
+    struct tlv *tlv;
+
+    if (((struct full_message *)(self->data))->marker != QMI_MESSAGE_QMUX_MARKER) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_INVALID_MESSAGE,
+                     "Marker is incorrect");
+        return FALSE;
+    }
+
+    if (get_qmux_length (self) < sizeof (struct qmux)) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_INVALID_MESSAGE,
+                     "QMUX length too short for QMUX header (%u < %" G_GSIZE_FORMAT ")",
+                     get_qmux_length (self), sizeof (struct qmux));
+        return FALSE;
+    }
+
+    /*
+     * qmux length is one byte shorter than buffer length because qmux
+     * length does not include the qmux frame marker.
+     */
+    if (get_qmux_length (self) != self->len - 1) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_INVALID_MESSAGE,
+                     "QMUX length and buffer length don't match (%u != %u)",
+                     get_qmux_length (self), self->len - 1);
+        return FALSE;
+    }
+
+    header_length = sizeof (struct qmux) + (message_is_control (self) ?
+                                            sizeof (struct control_header) :
+                                            sizeof (struct service_header));
+
+    if (get_qmux_length (self) < header_length) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_INVALID_MESSAGE,
+                     "QMUX length too short for QMI header (%u < %" G_GSIZE_FORMAT ")",
+                     get_qmux_length (self), header_length);
+        return FALSE;
+    }
+
+    if (get_qmux_length (self) - header_length != get_all_tlvs_length (self)) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_INVALID_MESSAGE,
+                     "QMUX length and QMI TLV lengths don't match (%u - %" G_GSIZE_FORMAT " != %u)",
+                     get_qmux_length (self), header_length, get_all_tlvs_length (self));
+        return FALSE;
+    }
+
+    end = qmi_end (self);
+    for (tlv = qmi_tlv (self); tlv < (struct tlv *)end; tlv = tlv_next (tlv)) {
+        if (tlv->value > end) {
+            g_set_error (error,
+                         QMI_CORE_ERROR,
+                         QMI_CORE_ERROR_INVALID_MESSAGE,
+                         "TLV header runs over buffer (%p > %p)",
+                         tlv->value, end);
+            return FALSE;
+        }
+        if (tlv->value + GUINT16_FROM_LE (tlv->length) > end) {
+            g_set_error (error,
+                         QMI_CORE_ERROR,
+                         QMI_CORE_ERROR_INVALID_MESSAGE,
+                         "TLV value runs over buffer (%p + %u  > %p)",
+                         tlv->value, GUINT16_FROM_LE (tlv->length), end);
+            return FALSE;
+        }
+    }
+
+    /*
+     * If this assert triggers, one of the if statements in the loop is wrong.
+     * (It shouldn't be reached on malformed QMI messages.)
+     */
+    g_assert (tlv == (struct tlv *)end);
+
+    return TRUE;
+}
+
+/**
+ * qmi_message_new:
+ * @service: a #QmiService
+ * @client_id: client ID of the originating control point.
+ * @transaction_id: transaction ID.
+ * @message_id: message ID.
+ *
+ * Create a new #QmiMessage with the specified parameters.
+ *
+ * Note that @transaction_id must be less than #G_MAXUINT8 if @service is
+ * #QMI_SERVICE_CTL.
+ *
+ * Returns: (transfer full): a newly created #QmiMessage. The returned value should be freed with qmi_message_unref().
+ */
+QmiMessage *
+qmi_message_new (QmiService service,
+                 guint8 client_id,
+                 guint16 transaction_id,
+                 guint16 message_id)
+{
+    GByteArray *self;
+    struct full_message *buffer;
+    gsize buffer_len;
+
+    /* Transaction ID in the control service is 8bit only */
+    g_return_val_if_fail ((service != QMI_SERVICE_CTL || transaction_id <= G_MAXUINT8),
+                          NULL);
+
+    /* Create array with enough size for the QMUX marker, the QMUX header and
+     * the QMI header */
+    buffer_len = (1 +
+                  sizeof (struct qmux) +
+                  (service == QMI_SERVICE_CTL ? sizeof (struct control_header) : sizeof (struct service_header)));
+    buffer = g_malloc (buffer_len);
+
+    buffer->marker = QMI_MESSAGE_QMUX_MARKER;
+    buffer->qmux.flags = 0;
+    buffer->qmux.service = service;
+    buffer->qmux.client = client_id;
+
+    if (service == QMI_SERVICE_CTL) {
+        buffer->qmi.control.header.flags = 0;
+        buffer->qmi.control.header.transaction = (guint8)transaction_id;
+        buffer->qmi.control.header.message = GUINT16_TO_LE (message_id);
+    } else {
+        buffer->qmi.service.header.flags = 0;
+        buffer->qmi.service.header.transaction = GUINT16_TO_LE (transaction_id);
+        buffer->qmi.service.header.message = GUINT16_TO_LE (message_id);
+    }
+
+    /* Create the GByteArray */
+    self = g_byte_array_new_take ((guint8 *)buffer, buffer_len);
+
+    /* Update length fields. */
+    set_qmux_length (self, buffer_len - 1); /* QMUX marker not included in length */
+    set_all_tlvs_length (self, 0);
+
+    /* We shouldn't create invalid empty messages */
+    g_assert (message_check (self, NULL));
+
+    return (QmiMessage *)self;
+}
+
+/**
+ * qmi_message_ref:
+ * @self: a #QmiMessage.
+ *
+ * Atomically increments the reference count of @self by one.
+ *
+ * Returns: (transfer full) the new reference to @self.
+ */
+QmiMessage *
+qmi_message_ref (QmiMessage *self)
+{
+    g_return_val_if_fail (self != NULL, NULL);
+
+    return (QmiMessage *)g_byte_array_ref (self);
+}
+
+/**
+ * qmi_message_unref:
+ * @self: a #QmiMessage.
+ *
+ * Atomically decrements the reference count of @self by one.
+ * If the reference count drops to 0, @self is completely disposed.
+ */
+void
+qmi_message_unref (QmiMessage *self)
+{
+    g_return_if_fail (self != NULL);
+
+    g_byte_array_unref (self);
+}
+
+/**
+ * qmi_message_get_raw:
+ * @self: a #QmiMessage.
+ * @length: (out): return location for the size of the output buffer.
+ * @error: return location for error or %NULL.
+ *
+ * Gets the raw data buffer of the #QmiMessage.
+ *
+ * Returns: (transfer none): The raw data buffer, or #NULL if @error is set.
+ */
+const guint8 *
+qmi_message_get_raw (QmiMessage *self,
+                     gsize *length,
+                     GError **error)
+{
+    g_return_val_if_fail (self != NULL, NULL);
+    g_return_val_if_fail (length != NULL, NULL);
+
+    *length = self->len;
+    return self->data;
+}
+
+/**
+ * qmi_message_get_raw_tlv:
+ * @self: a #QmiMessage.
+ * @type: specific ID of the TLV to get.
+ * @length: (out): return location for the length of the TLV.
+ *
+ * Get the raw data buffer of a specific TLV within the #QmiMessage.
+ *
+ * Returns: (transfer none): The raw data buffer of the TLV, or #NULL if not found.
+ */
+const guint8 *
+qmi_message_get_raw_tlv (QmiMessage *self,
+                         guint8 type,
+                         guint16 *length)
+{
+    struct tlv *tlv;
+
+    g_return_val_if_fail (self != NULL, NULL);
+    g_return_val_if_fail (length != NULL, NULL);
+
+    for (tlv = qmi_tlv_first (self); tlv; tlv = qmi_tlv_next (self, tlv)) {
+        if (tlv->type == type) {
+            *length = GUINT16_FROM_LE (tlv->length);
+            return (guint8 *)&(tlv->value[0]);
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * qmi_message_foreach_raw_tlv:
+ * @self: a #QmiMessage.
+ * @func: the function to call for each TLV.
+ * @user_data: user data to pass to the function.
+ *
+ * Calls the given function for each TLV found within the #QmiMessage.
+ */
+void
+qmi_message_foreach_raw_tlv (QmiMessage *self,
+                             QmiMessageForeachRawTlvFn func,
+                             gpointer user_data)
+{
+    struct tlv *tlv;
+
+    g_return_if_fail (self != NULL);
+    g_return_if_fail (func != NULL);
+
+    for (tlv = qmi_tlv_first (self); tlv; tlv = qmi_tlv_next (self, tlv)) {
+        func (tlv->type,
+              (const guint8 *)tlv->value,
+              (gsize)(GUINT16_FROM_LE (tlv->length)),
+              user_data);
+    }
+}
+
+/**
+ * qmi_message_add_raw_tlv:
+ * @self: a #QmiMessage.
+ * @type: specific ID of the TLV to add.
+ * @raw: raw data buffer with the value of the TLV.
+ * @length: length of the raw data buffer.
+ * @error: return location for error or %NULL.
+ *
+ * Creates a new @type TLV with the value given in @raw, and adds it to the #QmiMessage.
+ *
+ * Returns: %TRUE if the TLV as successfully added, otherwise %FALSE is returned and @error is set.
+ */
+gboolean
+qmi_message_add_raw_tlv (QmiMessage *self,
+                         guint8 type,
+                         const guint8 *raw,
+                         gsize length,
+                         GError **error)
+{
+    size_t tlv_len;
+    struct tlv *tlv;
+
+    g_return_val_if_fail (self != NULL, FALSE);
+    g_return_val_if_fail (raw != NULL, FALSE);
+    g_return_val_if_fail (length > 0, FALSE);
+
+    /* Find length of new TLV */
+    tlv_len = sizeof (struct tlv) + length;
+
+    /* Check for overflow of message size. */
+    if (get_qmux_length (self) + tlv_len > G_MAXUINT16) {
+        g_set_error (error,
+                     QMI_CORE_ERROR,
+                     QMI_CORE_ERROR_TLV_TOO_LONG,
+                     "TLV to add is too long");
+        return FALSE;
+    }
+
+    /* Resize buffer. */
+    g_byte_array_set_size (self, self->len + tlv_len);
+
+    /* Fill in new TLV. */
+    tlv = (struct tlv *)(qmi_end (self) - tlv_len);
+    tlv->type = type;
+    tlv->length = GUINT16_TO_LE (length);
+    memcpy (tlv->value, raw, length);
+
+    /* Update length fields. */
+    set_qmux_length (self, (guint16)(get_qmux_length (self) + tlv_len));
+    set_all_tlvs_length (self, (guint16)(get_all_tlvs_length (self) + tlv_len));
+
+    /* Make sure we didn't break anything. */
+    g_assert (message_check (self, error));
+
+    return TRUE;
+}
+
+/**
+ * qmi_message_new_from_raw:
+ * @raw: (inout): raw data buffer.
+ * @error: return location for error or %NULL.
+ *
+ * Create a new #QmiMessage from the given raw data buffer.
+ *
+ * Whenever a complete QMI message is read, its raw data gets removed from the @raw buffer.
+ *
+ * Returns: (transfer full): a newly created #QmiMessage, which should be freed with qmi_message_unref(). If @raw doesn't contain a complete QMI message #NULL is returned. If there is a complete QMI message but it appears not to be valid, #NULL is returned and @error is set.
+ */
+QmiMessage *
+qmi_message_new_from_raw (GByteArray *raw,
+                          GError **error)
+{
+    GByteArray *self;
+    gsize message_len;
+
+    g_return_val_if_fail (raw != NULL, NULL);
+
+    /* If we didn't even read the QMUX header (comes after the 1-byte marker),
+     * leave */
+    if (raw->len < (sizeof (struct qmux) + 1))
+        return NULL;
+
+    /* We need to have read the length reported by the QMUX header (plus the
+     * initial 1-byte marker) */
+    message_len = GUINT16_FROM_LE (((struct full_message *)raw->data)->qmux.length);
+    if (raw->len < (message_len + 1)) {
+        g_printerr ("\ngot '%u' bytes, need '%u' bytes\n",
+                    (guint)raw->len,
+                    (guint)(message_len + 1));
+        return NULL;
+    }
+
+    /* Ok, so we should have all the data available already */
+    self = g_byte_array_sized_new (message_len + 1);
+    g_byte_array_prepend (self, raw->data, message_len + 1);
+
+    /* We got a complete QMI message, remove from input buffer */
+    g_byte_array_remove_range (raw, 0, self->len);
+
+    /* Check input message validity as soon as we create the QmiMessage */
+    if (!message_check (self, error)) {
+        /* Yes, we lose the whole message here */
+        qmi_message_unref (self);
+        return NULL;
+    }
+
+    return (QmiMessage *)self;
+}
+
+/**
+ * qmi_message_get_tlv_printable:
+ * @self: a #QmiMessage.
+ * @line_prefix: prefix string to use in each new generated line.
+ * @type: type of the TLV.
+ * @raw: raw data buffer with the value of the TLV.
+ * @raw_length: length of the raw data buffer.
+ *
+ * Gets a printable string with the contents of the TLV.
+ *
+ * This method is the most generic one and doesn't try to translate the TLV contents.
+ *
+ * Returns: (transfer full): a newly allocated string, which should be freed with g_free().
+ */
+gchar *
+qmi_message_get_tlv_printable (QmiMessage *self,
+                               const gchar *line_prefix,
+                               guint8 type,
+                               const guint8 *raw,
+                               gsize raw_length)
+{
+    gchar *printable;
+    gchar *value_hex;
+
+    g_return_val_if_fail (self != NULL, NULL);
+    g_return_val_if_fail (line_prefix != NULL, NULL);
+    g_return_val_if_fail (raw != NULL, NULL);
+    g_return_val_if_fail (raw_length > 0, NULL);
+
+    value_hex = __qmi_utils_str_hex (raw, raw_length, ':');
+    printable = g_strdup_printf ("%sTLV:\n"
+                                 "%s  type   = 0x%02x\n"
+                                 "%s  length = %" G_GSIZE_FORMAT "\n"
+                                 "%s  value  = %s\n",
+                                 line_prefix,
+                                 line_prefix, type,
+                                 line_prefix, raw_length,
+                                 line_prefix, value_hex);
+    g_free (value_hex);
+    return printable;
+}
+
+static gchar *
+get_generic_printable (QmiMessage *self,
+                       const gchar *line_prefix)
+{
+    GString *printable;
+    struct tlv *tlv;
+
+    printable = g_string_new ("");
+
+    g_string_append_printf (printable,
+                            "%s  message     = (0x%04x)\n",
+                            line_prefix, qmi_message_get_message_id (self));
+
+    for (tlv = qmi_tlv_first (self); tlv; tlv = qmi_tlv_next (self, tlv)) {
+        gchar *printable_tlv;
+
+        printable_tlv = qmi_message_get_tlv_printable (self,
+                                                       line_prefix,
+                                                       tlv->type,
+                                                       tlv->value,
+                                                       tlv->length);
+        g_string_append (printable, printable_tlv);
+        g_free (printable_tlv);
+    }
+
+    return g_string_free (printable, FALSE);
+}
+
+/**
+ * qmi_message_get_printable:
+ * @self: a #QmiMessage.
+ * @line_prefix: prefix string to use in each new generated line.
+ *
+ * Gets a printable string with the contents of the whole QMI message.
+ *
+ * If known, the printable string will contain translated TLV values as well as the raw
+ * data buffer contents.
+ *
+ * Returns: (transfer full): a newly allocated string, which should be freed with g_free().
+ */
+gchar *
+qmi_message_get_printable (QmiMessage *self,
+                           const gchar *line_prefix)
+{
+    GString *printable;
+    gchar *qmi_flags_str;
+    gchar *contents;
+
+    g_return_val_if_fail (self != NULL, NULL);
+    g_return_val_if_fail (line_prefix != NULL, NULL);
+
+    if (!line_prefix)
+        line_prefix = "";
+
+    printable = g_string_new ("");
+    g_string_append_printf (printable,
+                            "%sQMUX:\n"
+                            "%s  length  = %u\n"
+                            "%s  flags   = 0x%02x\n"
+                            "%s  service = \"%s\"\n"
+                            "%s  client  = %u\n",
+                            line_prefix,
+                            line_prefix, get_qmux_length (self),
+                            line_prefix, get_qmux_flags (self),
+                            line_prefix, qmi_service_get_string (qmi_message_get_service (self)),
+                            line_prefix, qmi_message_get_client_id (self));
+
+    if (qmi_message_get_service (self) == QMI_SERVICE_CTL)
+        qmi_flags_str = qmi_ctl_flag_build_string_from_mask (get_qmi_flags (self));
+    else
+        qmi_flags_str = qmi_service_flag_build_string_from_mask (get_qmi_flags (self));
+
+    g_string_append_printf (printable,
+                            "%sQMI:\n"
+                            "%s  flags       = \"%s\"\n"
+                            "%s  transaction = %u\n"
+                            "%s  tlv_length  = %u\n",
+                            line_prefix,
+                            line_prefix, qmi_flags_str,
+                            line_prefix, qmi_message_get_transaction_id (self),
+                            line_prefix, get_all_tlvs_length (self));
+    g_free (qmi_flags_str);
+
+    contents = NULL;
+    switch (qmi_message_get_service (self)) {
+    case QMI_SERVICE_CTL:
+        contents = __qmi_message_ctl_get_printable (self, line_prefix);
+        break;
+    case QMI_SERVICE_DMS:
+        contents = __qmi_message_dms_get_printable (self, line_prefix);
+        break;
+    case QMI_SERVICE_WDS:
+        contents = __qmi_message_wds_get_printable (self, line_prefix);
+        break;
+    case QMI_SERVICE_NAS:
+        contents = __qmi_message_nas_get_printable (self, line_prefix);
+        break;
+    case QMI_SERVICE_WMS:
+        contents = __qmi_message_wms_get_printable (self, line_prefix);
+        break;
+    case QMI_SERVICE_PDS:
+        contents = __qmi_message_pds_get_printable (self, line_prefix);
+        break;
+    case QMI_SERVICE_UIM:
+        contents = __qmi_message_uim_get_printable (self, line_prefix);
+        break;
+    default:
+        break;
+    }
+
+    if (!contents)
+        contents = get_generic_printable (self, line_prefix);
+    g_string_append (printable, contents);
+    g_free (contents);
+
+    return g_string_free (printable, FALSE);
+}
+
+/**
+ * qmi_message_get_version_introduced:
+ * @self: a #QmiMessage.
+ * @major: (out) return location for the major version.
+ * @minor: (out) return location for the minor version.
+ *
+ * Gets, if known, the service version in which the given message was first introduced.
+ *
+ * Returns: %TRUE if @major and @minor are set, %FALSE otherwise.
+ */
+gboolean
+qmi_message_get_version_introduced (QmiMessage *self,
+                                    guint *major,
+                                    guint *minor)
+{
+    switch (qmi_message_get_service (self)) {
+    case QMI_SERVICE_CTL:
+        /* For CTL service, we'll assume the minimum one */
+        *major = 0;
+        *minor = 0;
+        return TRUE;
+
+    case QMI_SERVICE_DMS:
+        return __qmi_message_dms_get_version_introduced (self, major, minor);
+
+    case QMI_SERVICE_WDS:
+        return __qmi_message_wds_get_version_introduced (self, major, minor);
+
+    case QMI_SERVICE_NAS:
+        return __qmi_message_nas_get_version_introduced (self, major, minor);
+
+    case QMI_SERVICE_WMS:
+        return __qmi_message_wms_get_version_introduced (self, major, minor);
+
+    case QMI_SERVICE_PDS:
+        return __qmi_message_pds_get_version_introduced (self, major, minor);
+
+    case QMI_SERVICE_UIM:
+        return __qmi_message_uim_get_version_introduced (self, major, minor);
+
+    default:
+        /* For the still unsupported services, cannot do anything */
+        return FALSE;
+    }
+}
diff --git a/src/libqmi-glib/qmi-message.h b/src/libqmi-glib/qmi-message.h
new file mode 100644
index 0000000..ae88671
--- /dev/null
+++ b/src/libqmi-glib/qmi-message.h
@@ -0,0 +1,114 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ * Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_MESSAGE_H_
+#define _LIBQMI_GLIB_QMI_MESSAGE_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+#include <glib.h>
+
+#include "qmi-enums.h"
+
+G_BEGIN_DECLS
+
+#define QMI_MESSAGE_QMUX_MARKER (guint8)0x01
+
+/**
+ * QmiMessage:
+ *
+ * An opaque type representing a QMI message.
+ */
+typedef GByteArray QmiMessage;
+
+/*****************************************************************************/
+/* QMI Message life cycle */
+
+QmiMessage   *qmi_message_new          (QmiService service,
+                                        guint8 client_id,
+                                        guint16 transaction_id,
+                                        guint16 message_id);
+QmiMessage   *qmi_message_new_from_raw (GByteArray *raw,
+                                        GError **error);
+QmiMessage   *qmi_message_ref          (QmiMessage *self);
+void          qmi_message_unref        (QmiMessage *self);
+
+/*****************************************************************************/
+/* QMI Message content getters */
+
+gboolean      qmi_message_is_response           (QmiMessage *self);
+gboolean      qmi_message_is_indication         (QmiMessage *self);
+QmiService    qmi_message_get_service           (QmiMessage *self);
+guint8        qmi_message_get_client_id         (QmiMessage *self);
+guint16       qmi_message_get_transaction_id    (QmiMessage *self);
+guint16       qmi_message_get_message_id        (QmiMessage *self);
+gsize         qmi_message_get_length            (QmiMessage *self);
+const guint8 *qmi_message_get_raw               (QmiMessage *self,
+                                                 gsize *length,
+                                                 GError **error);
+gboolean     qmi_message_get_version_introduced (QmiMessage *self,
+                                                 guint *major,
+                                                 guint *minor);
+
+/*****************************************************************************/
+/* Raw TLV handling */
+
+typedef void (* QmiMessageForeachRawTlvFn) (guint8 type,
+                                            const guint8 *value,
+                                            gsize length,
+                                            gpointer user_data);
+void          qmi_message_foreach_raw_tlv  (QmiMessage *self,
+                                            QmiMessageForeachRawTlvFn func,
+                                            gpointer user_data);
+const guint8 *qmi_message_get_raw_tlv      (QmiMessage *self,
+                                            guint8 type,
+                                            guint16 *length);
+gboolean      qmi_message_add_raw_tlv      (QmiMessage *self,
+                                            guint8 type,
+                                            const guint8 *raw,
+                                            gsize length,
+                                            GError **error);
+
+/*****************************************************************************/
+/* Printable helpers */
+
+gchar *qmi_message_get_printable (QmiMessage *self,
+                                  const gchar *line_prefix);
+
+gchar *qmi_message_get_tlv_printable (QmiMessage *self,
+                                      const gchar *line_prefix,
+                                      guint8 type,
+                                      const guint8 *raw,
+                                      gsize raw_length);
+
+G_END_DECLS
+
+#endif /* _LIBQMI_GLIB_QMI_MESSAGE_H_ */
diff --git a/src/libqmi-glib/qmi-utils.c b/src/libqmi-glib/qmi-utils.c
new file mode 100644
index 0000000..8482277
--- /dev/null
+++ b/src/libqmi-glib/qmi-utils.c
@@ -0,0 +1,1024 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ * Copyright (C) 2012 Dan Williams <dcbw@redhat.com>
+ */
+
+#include <config.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include "qmi-utils.h"
+
+/**
+ * SECTION:qmi-utils
+ * @title: Common utilities
+ *
+ * This section exposes a set of common utilities that may be used to work
+ * with the QMI library.
+ **/
+
+/*****************************************************************************/
+
+gchar *
+__qmi_utils_str_hex (gconstpointer mem,
+                     gsize size,
+                     gchar delimiter)
+{
+    const guint8 *data = mem;
+	gsize i;
+	gsize j;
+	gsize new_str_length;
+	gchar *new_str;
+
+	/* Get new string length. If input string has N bytes, we need:
+	 * - 1 byte for last NUL char
+	 * - 2N bytes for hexadecimal char representation of each byte...
+	 * - N-1 bytes for the separator ':'
+	 * So... a total of (1+2N+N-1) = 3N bytes are needed... */
+	new_str_length =  3 * size;
+
+	/* Allocate memory for new array and initialize contents to NUL */
+	new_str = g_malloc0 (new_str_length);
+
+	/* Print hexadecimal representation of each byte... */
+	for (i = 0, j = 0; i < size; i++, j += 3) {
+		/* Print character in output string... */
+		snprintf (&new_str[j], 3, "%02X", data[i]);
+		/* And if needed, add separator */
+		if (i != (size - 1) )
+			new_str[j + 2] = delimiter;
+	}
+
+	/* Set output string */
+	return new_str;
+}
+
+/*****************************************************************************/
+
+#if defined UTILS_ENABLE_TRACE
+static void
+print_read_bytes_trace (const gchar *type,
+                        gconstpointer buffer,
+                        gconstpointer out,
+                        guint n_bytes)
+{
+    gchar *str1;
+    gchar *str2;
+
+    str1 = __qmi_utils_str_hex (buffer, n_bytes, ':');
+    str2 = __qmi_utils_str_hex (out, n_bytes, ':');
+
+    g_debug ("Read %s (%s) --> (%s)", type, str1, str2);
+    g_warn_if_fail (g_str_equal (str1, str2));
+
+    g_free (str1);
+    g_free (str2);
+}
+#else
+#define print_read_bytes_trace(...)
+#endif
+
+/**
+ * qmi_utils_read_guint8_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @out: return location for the read variable.
+ *
+ * Reads an unsigned byte from the buffer.
+ *
+ * The user needs to make sure that at least 1 byte is available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 1 byte
+ * read.
+ */
+void
+qmi_utils_read_guint8_from_buffer (const guint8 **buffer,
+                                   guint16       *buffer_size,
+                                   guint8        *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 1);
+
+    *out = (*buffer)[0];
+
+    print_read_bytes_trace ("guint8", &(*buffer)[0], out, 1);
+
+    *buffer = &((*buffer)[1]);
+    *buffer_size = (*buffer_size) - 1;
+}
+
+/**
+ * qmi_utils_read_gint8_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @out: return location for the read variable.
+ *
+ * Reads a signed byte from the buffer.
+ *
+ * The user needs to make sure that at least 1 byte is available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 1 byte
+ * read.
+ */
+void
+qmi_utils_read_gint8_from_buffer (const guint8 **buffer,
+                                  guint16       *buffer_size,
+                                  gint8         *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 1);
+
+    *out = (gint8)(*buffer)[0];
+
+    print_read_bytes_trace ("gint8", &(*buffer)[0], out, 1);
+
+    *buffer = &((*buffer)[1]);
+    *buffer_size = (*buffer_size) - 1;
+}
+
+/**
+ * qmi_utils_read_guint16_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads an unsigned 16-bit integer from the buffer. The number in the buffer is
+ * expected to be given in the byte order specificed by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
+ *
+ * The user needs to make sure that at least 2 bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 2 bytes
+ * read.
+ */
+void
+qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
+                                    guint16       *buffer_size,
+                                    QmiEndian      endian,
+                                    guint16       *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 2);
+
+    memcpy (out, &((*buffer)[0]), 2);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT16_FROM_BE (*out);
+    else
+        *out = GUINT16_FROM_LE (*out);
+
+    print_read_bytes_trace ("guint16", &(*buffer)[0], out, 2);
+
+    *buffer = &((*buffer)[2]);
+    *buffer_size = (*buffer_size) - 2;
+}
+
+/**
+ * qmi_utils_read_gint16_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads a signed 16-bit integer from the buffer. The number in the buffer is
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
+ *
+ * The user needs to make sure that at least 2 bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 2 bytes
+ * read.
+ */
+void
+qmi_utils_read_gint16_from_buffer (const guint8 **buffer,
+                                   guint16       *buffer_size,
+                                   QmiEndian      endian,
+                                   gint16        *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 2);
+
+    memcpy (out, &((*buffer)[0]), 2);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GINT16_FROM_BE (*out);
+    else
+        *out = GINT16_FROM_LE (*out);
+
+    print_read_bytes_trace ("gint16", &(*buffer)[0], out, 2);
+
+    *buffer = &((*buffer)[2]);
+    *buffer_size = (*buffer_size) - 2;
+}
+
+/**
+ * qmi_utils_read_guint32_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads an unsigned 32-bit integer from the buffer. The number in the buffer is
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
+ *
+ * The user needs to make sure that at least 4 bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 4 bytes
+ * read.
+ */
+void
+qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
+                                    guint16       *buffer_size,
+                                    QmiEndian      endian,
+                                    guint32       *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 4);
+
+    memcpy (out, &((*buffer)[0]), 4);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT32_FROM_BE (*out);
+    else
+        *out = GUINT32_FROM_LE (*out);
+
+    print_read_bytes_trace ("guint32", &(*buffer)[0], out, 4);
+
+    *buffer = &((*buffer)[4]);
+    *buffer_size = (*buffer_size) - 4;
+}
+
+/**
+ * qmi_utils_read_gint32_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads a signed 32-bit integer from the buffer. The number in the buffer is
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
+ *
+ * The user needs to make sure that at least 4 bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 4 bytes
+ * read.
+ */
+void
+qmi_utils_read_gint32_from_buffer (const guint8 **buffer,
+                                   guint16       *buffer_size,
+                                   QmiEndian      endian,
+                                   gint32        *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 4);
+
+    memcpy (out, &((*buffer)[0]), 4);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GINT32_FROM_BE (*out);
+    else
+        *out = GINT32_FROM_LE (*out);
+
+    print_read_bytes_trace ("gint32", &(*buffer)[0], out, 4);
+
+    *buffer = &((*buffer)[4]);
+    *buffer_size = (*buffer_size) - 4;
+}
+
+/**
+ * qmi_utils_read_guint64_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads an unsigned 64-bit integer from the buffer. The number in the buffer is
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
+ *
+ * The user needs to make sure that at least 8 bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 8 bytes
+ * read.
+ */
+void
+qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
+                                    guint16       *buffer_size,
+                                    QmiEndian      endian,
+                                    guint64       *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 8);
+
+    memcpy (out, &((*buffer)[0]), 8);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT64_FROM_BE (*out);
+    else
+        *out = GUINT64_FROM_LE (*out);
+
+    print_read_bytes_trace ("guint64", &(*buffer)[0], out, 8);
+
+    *buffer = &((*buffer)[8]);
+    *buffer_size = (*buffer_size) - 8;
+}
+
+/**
+ * qmi_utils_read_gint64_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads a signed 64-bit integer from the buffer. The number in the buffer is
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
+ *
+ * The user needs to make sure that at least 8 bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 8 bytes
+ * read.
+ */
+void
+qmi_utils_read_gint64_from_buffer (const guint8 **buffer,
+                                   guint16       *buffer_size,
+                                   QmiEndian      endian,
+                                   gint64        *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 8);
+
+    memcpy (out, &((*buffer)[0]), 8);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GINT64_FROM_BE (*out);
+    else
+        *out = GINT64_FROM_LE (*out);
+
+    print_read_bytes_trace ("gint64", &(*buffer)[0], out, 8);
+
+    *buffer = &((*buffer)[8]);
+    *buffer_size = (*buffer_size) - 8;
+}
+
+/**
+ * qmi_utils_read_sized_guint_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @n_bytes: number of bytes to read.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
+ * @out: return location for the read variable.
+ *
+ * Reads a @n_bytes-sized unsigned integer from the buffer. The number in the
+ * buffer is expected to be given in the byte order specified by @endian, and
+ * this method takes care of converting the read value to the proper host
+ * endianness.
+ *
+ * The user needs to make sure that at least @n_bytes bytes are available
+ * in the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the @n_bytes
+ * bytes read.
+ */
+void
+qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
+                                        guint16       *buffer_size,
+                                        guint          n_bytes,
+                                        QmiEndian      endian,
+                                        guint64       *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= n_bytes);
+    g_assert (n_bytes <= 8);
+
+    *out = 0;
+
+    /* In Little Endian, we copy the bytes to the beginning of the output
+     * buffer. */
+    if (endian == QMI_ENDIAN_LITTLE) {
+        memcpy (out, *buffer, n_bytes);
+        *out = GUINT64_FROM_LE (*out);
+    }
+    /* In Big Endian, we copy the bytes to the end of the output buffer */
+    else {
+        guint8 tmp[8] = { 0 };
+
+        memcpy (&tmp[8 - n_bytes], *buffer, n_bytes);
+        memcpy (out, &tmp[0], 8);
+        *out = GUINT64_FROM_BE (*out);
+    }
+
+    *buffer = &((*buffer)[n_bytes]);
+    *buffer_size = (*buffer_size) - n_bytes;
+}
+
+/**
+ * qmi_utils_write_guint8_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @in: location of the variable to be written.
+ *
+ * Writes an unsigned byte into the buffer.
+ *
+ * The user needs to make sure that the buffer is at least 1 byte long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 1 byte
+ * write.
+ */
+void
+qmi_utils_write_guint8_to_buffer (guint8  **buffer,
+                                  guint16  *buffer_size,
+                                  guint8   *in)
+{
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 1);
+
+    memcpy (&(*buffer)[0], in, sizeof (*in));
+
+    *buffer = &((*buffer)[1]);
+    *buffer_size = (*buffer_size) - 1;
+}
+
+/**
+ * qmi_utils_write_gint8_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @in: location of the variable to be written.
+ *
+ * Writes a signed byte into the buffer.
+ *
+ * The user needs to make sure that the buffer is at least 1 byte long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 1 byte
+ * write.
+ */
+void
+qmi_utils_write_gint8_to_buffer (guint8  **buffer,
+                                 guint16  *buffer_size,
+                                 gint8    *in)
+{
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 1);
+
+    memcpy (&(*buffer)[0], in, sizeof (*in));
+
+    *buffer = &((*buffer)[1]);
+    *buffer_size = (*buffer_size) - 1;
+}
+
+/**
+ * qmi_utils_write_guint16_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes an unsigned 16-bit integer into the buffer. The number to be written
+ * is expected to be given in host endianness, and this method takes care of
+ * converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least 2 bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 2 bytes
+ * write.
+ */
+void
+qmi_utils_write_guint16_to_buffer (guint8  **buffer,
+                                   guint16  *buffer_size,
+                                   QmiEndian endian,
+                                   guint16  *in)
+{
+    guint16 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 2);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT16_TO_BE (*in);
+    else
+        tmp = GUINT16_TO_LE (*in);
+    memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
+
+    *buffer = &((*buffer)[2]);
+    *buffer_size = (*buffer_size) - 2;
+}
+
+/**
+ * qmi_utils_write_gint16_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes a signed 16-bit integer into the buffer. The number to be written
+ * is expected to be given in host endianness, and this method takes care of
+ * converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least 2 bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 2 bytes
+ * write.
+ */
+void
+qmi_utils_write_gint16_to_buffer (guint8  **buffer,
+                                  guint16  *buffer_size,
+                                  QmiEndian endian,
+                                  gint16   *in)
+{
+    gint16 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 2);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GINT16_TO_BE (*in);
+    else
+        tmp = GINT16_TO_LE (*in);
+    memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
+
+    *buffer = &((*buffer)[2]);
+    *buffer_size = (*buffer_size) - 2;
+}
+
+/**
+ * qmi_utils_write_guint32_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes an unsigned 32-bit integer into the buffer. The number to be written
+ * is expected to be given in host endianness, and this method takes care of
+ * converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least 4 bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 4 bytes
+ * write.
+ */
+void
+qmi_utils_write_guint32_to_buffer (guint8  **buffer,
+                                   guint16  *buffer_size,
+                                   QmiEndian endian,
+                                   guint32  *in)
+{
+    guint32 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 4);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT32_TO_BE (*in);
+    else
+        tmp = GUINT32_TO_LE (*in);
+    memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
+
+    *buffer = &((*buffer)[4]);
+    *buffer_size = (*buffer_size) - 4;
+}
+
+/**
+ * qmi_utils_write_gint32_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes a signed 32-bit integer into the buffer. The number to be written
+ * is expected to be given in host endianness, and this method takes care of
+ * converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least 4 bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 4 bytes
+ * write.
+ */
+void
+qmi_utils_write_gint32_to_buffer (guint8  **buffer,
+                                  guint16  *buffer_size,
+                                  QmiEndian endian,
+                                  gint32   *in)
+{
+    gint32 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 4);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GINT32_TO_BE (*in);
+    else
+        tmp = GINT32_TO_LE (*in);
+    memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
+
+    *buffer = &((*buffer)[4]);
+    *buffer_size = (*buffer_size) - 4;
+}
+
+/**
+ * qmi_utils_write_guint64_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes an unsigned 64-bit integer into the buffer. The number to be written
+ * is expected to be given in host endianness, and this method takes care of
+ * converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least 8 bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 8 bytes
+ * write.
+ */
+void
+qmi_utils_write_guint64_to_buffer (guint8  **buffer,
+                                   guint16  *buffer_size,
+                                   QmiEndian endian,
+                                   guint64  *in)
+{
+    guint64 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 8);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT64_TO_BE (*in);
+    else
+        tmp = GUINT64_TO_LE (*in);
+    memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
+
+    *buffer = &((*buffer)[8]);
+    *buffer_size = (*buffer_size) - 8;
+}
+
+/**
+ * qmi_utils_write_gint64_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes a signed 64-bit integer into the buffer. The number to be written
+ * is expected to be given in host endianness, and this method takes care of
+ * converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least 8 bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the 8 bytes
+ * write.
+ */
+void
+qmi_utils_write_gint64_to_buffer (guint8  **buffer,
+                                  guint16  *buffer_size,
+                                  QmiEndian endian,
+                                  gint64   *in)
+{
+    gint64 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= 8);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GINT64_TO_BE (*in);
+    else
+        tmp = GINT64_TO_LE (*in);
+    memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
+
+    *buffer = &((*buffer)[8]);
+    *buffer_size = (*buffer_size) - 8;
+}
+
+/**
+ * qmi_utils_write_sized_guint_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @n_bytes: number of bytes to write.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
+ * @in: location of the variable to be written.
+ *
+ * Writes a @n_bytes-sized unsigned integer into the buffer. The number to be
+ * written is expected to be given in host endianness, and this method takes
+ * care of converting the value written to the byte order specified by @endian.
+ *
+ * The user needs to make sure that the buffer is at least @n_bytes bytes long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the @n_bytes
+ * bytes write.
+ */
+void
+qmi_utils_write_sized_guint_to_buffer (guint8  **buffer,
+                                       guint16  *buffer_size,
+                                       guint     n_bytes,
+                                       QmiEndian endian,
+                                       guint64  *in)
+{
+    guint64 tmp;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (*buffer_size >= n_bytes);
+    g_assert (n_bytes <= 8);
+
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT64_TO_BE (*in);
+    else
+        tmp = GUINT64_TO_LE (*in);
+
+    /* In Little Endian, we read the bytes from the beginning of the buffer */
+    if (endian == QMI_ENDIAN_LITTLE) {
+        memcpy (*buffer, &tmp, n_bytes);
+    }
+    /* In Big Endian, we read the bytes from the end of the buffer */
+    else {
+        guint8 tmp_buffer[8];
+
+        memcpy (&tmp_buffer[0], &tmp, 8);
+        memcpy (*buffer, &tmp_buffer[8 - n_bytes], n_bytes);
+    }
+
+    *buffer = &((*buffer)[n_bytes]);
+    *buffer_size = (*buffer_size) - n_bytes;
+}
+
+/**
+ * qmi_utils_read_string_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @length_prefix_size: size of the length prefix integer in bits.
+ * @max_size: maximum number of bytes to read, or 0 to read all available bytes.
+ * @out: return location for the read string. The returned value should be freed with g_free().
+ *
+ * Reads a string from the buffer.
+ *
+ * If @length_prefix_size is greater than 0, only the amount of bytes given
+ * there will be read. Otherwise, up to @buffer_size bytes will be read.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the write.
+ */
+void
+qmi_utils_read_string_from_buffer (const guint8 **buffer,
+                                   guint16       *buffer_size,
+                                   guint8         length_prefix_size,
+                                   guint16        max_size,
+                                   gchar        **out)
+{
+    guint16 string_length;
+    guint16 valid_string_length;
+    guint8 string_length_8;
+    guint16 string_length_16;
+
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (length_prefix_size == 0 ||
+              length_prefix_size == 8 ||
+              length_prefix_size == 16);
+
+    switch (length_prefix_size) {
+    case 0:
+        /* If no length prefix given, read the whole buffer into a string */
+        string_length = *buffer_size;
+        break;
+    case 8:
+        qmi_utils_read_guint8_from_buffer (buffer,
+                                           buffer_size,
+                                           &string_length_8);
+        string_length = string_length_8;
+        break;
+    case 16:
+        qmi_utils_read_guint16_from_buffer (buffer,
+                                            buffer_size,
+                                            QMI_ENDIAN_LITTLE,
+                                            &string_length_16);
+        string_length = string_length_16;
+        break;
+    default:
+        g_assert_not_reached ();
+    }
+
+    if (max_size > 0 && string_length > max_size)
+        valid_string_length = max_size;
+    else
+        valid_string_length = string_length;
+
+    /* Read 'valid_string_length' bytes */
+    *out = g_malloc (valid_string_length + 1);
+    memcpy (*out, *buffer, valid_string_length);
+    (*out)[valid_string_length] = '\0';
+
+    /* And walk 'string_length' bytes */
+    *buffer = &((*buffer)[string_length]);
+    *buffer_size = (*buffer_size) - string_length;
+}
+
+/**
+ * qmi_utils_read_fixed_size_string_from_buffer:
+ * @buffer: a buffer with raw binary data.
+ * @buffer_size: size of @buffer.
+ * @fixed_size: number of bytes to read.
+ * @out: return location for the read string. The returned value should be freed with g_free().
+ *
+ * Reads a @fixed_size-sized string from the buffer.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the
+ * @fixed_size bytes read.
+ */
+void
+qmi_utils_read_fixed_size_string_from_buffer (const guint8 **buffer,
+                                              guint16       *buffer_size,
+                                              guint16        fixed_size,
+                                              gchar         *out)
+{
+    g_assert (out != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (fixed_size > 0);
+
+    memcpy (out, *buffer, fixed_size);
+
+    *buffer = &((*buffer)[fixed_size]);
+    *buffer_size = (*buffer_size) - fixed_size;
+}
+
+/**
+ * qmi_utils_write_string_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @length_prefix_size: size of the length prefix integer in bits.
+ * @in: string to write.
+ *
+ * Writes a string to the buffer.
+ *
+ * If @length_prefix_size is greater than 0, a length prefix integer will be
+ * included in the write operation.
+ *
+ * The user needs to make sure that the buffer has enough space for both the
+ * whole string and the length prefix.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the write.
+ */
+void
+qmi_utils_write_string_to_buffer (guint8      **buffer,
+                                  guint16      *buffer_size,
+                                  guint8        length_prefix_size,
+                                  const gchar  *in)
+{
+    guint16 len;
+    guint8 len_8;
+    guint16 len_16;
+
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (length_prefix_size == 0 ||
+              length_prefix_size == 8 ||
+              length_prefix_size == 16);
+
+    len = (guint16) strlen (in);
+
+    switch (length_prefix_size) {
+    case 0:
+        break;
+    case 8:
+        g_warn_if_fail (len <= G_MAXUINT8);
+        len_8 = (guint8)len;
+        qmi_utils_write_guint8_to_buffer (buffer,
+                                          buffer_size,
+                                          &len_8);
+        break;
+    case 16:
+        g_warn_if_fail (len <= G_MAXUINT16);
+        len_16 = (guint16)len;
+        qmi_utils_write_guint16_to_buffer (buffer,
+                                           buffer_size,
+                                           QMI_ENDIAN_LITTLE,
+                                           &len_16);
+        break;
+    default:
+        g_assert_not_reached ();
+    }
+
+    memcpy (*buffer, in, len);
+    *buffer = &((*buffer)[len]);
+    *buffer_size = (*buffer_size) - len;
+}
+
+/**
+ * qmi_utils_write_fixed_size_string_to_buffer:
+ * @buffer: a buffer.
+ * @buffer_size: size of @buffer.
+ * @fixed_size: number of bytes to write.
+ * @in: string to write.
+ *
+ * Writes a @fixed_size-sized string to the buffer, without any length prefix.
+ *
+ * The user needs to make sure that the buffer is at least @fixed_size bytes
+ * long.
+ *
+ * Also note that both @buffer and @buffer_size get updated after the
+ * @fixed_size bytes write.
+ */
+void
+qmi_utils_write_fixed_size_string_to_buffer (guint8      **buffer,
+                                             guint16      *buffer_size,
+                                             guint16       fixed_size,
+                                             const gchar  *in)
+{
+    g_assert (in != NULL);
+    g_assert (buffer != NULL);
+    g_assert (buffer_size != NULL);
+    g_assert (fixed_size > 0);
+
+    memcpy (*buffer, in, fixed_size);
+    *buffer = &((*buffer)[fixed_size]);
+    *buffer_size = (*buffer_size) - fixed_size;
+}
+
+/*****************************************************************************/
+
+static volatile gint __traces_enabled = FALSE;
+
+/**
+ * qmi_utils_get_traces_enabled:
+ *
+ * Checks whether QMI message traces are currently enabled.
+ *
+ * Returns: %TRUE if traces are enabled, %FALSE otherwise.
+ */
+gboolean
+qmi_utils_get_traces_enabled (void)
+{
+    return (gboolean) g_atomic_int_get (&__traces_enabled);
+}
+
+/**
+ * qmi_utils_set_traces_enabled:
+ * @enabled: %TRUE to enable traces, %FALSE to disable them.
+ *
+ * Sets whether QMI message traces are enabled or disabled.
+ */
+void
+qmi_utils_set_traces_enabled (gboolean enabled)
+{
+    g_atomic_int_set (&__traces_enabled, enabled);
+}
diff --git a/src/libqmi-glib/qmi-utils.h b/src/libqmi-glib/qmi-utils.h
new file mode 100644
index 0000000..3f39182
--- /dev/null
+++ b/src/libqmi-glib/qmi-utils.h
@@ -0,0 +1,166 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ * libqmi-glib -- GLib/GIO based library to control QMI devices
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ * Copyright (C) 2012 Dan Williams <dcbw@redhat.com>
+ */
+
+#ifndef _LIBQMI_GLIB_QMI_UTILS_H_
+#define _LIBQMI_GLIB_QMI_UTILS_H_
+
+#if !defined (__LIBQMI_GLIB_H_INSIDE__) && !defined (LIBQMI_GLIB_COMPILATION)
+#error "Only <libqmi-glib.h> can be included directly."
+#endif
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+/**
+ * QmiEndian:
+ * @QMI_ENDIAN_LITTLE: Little endian.
+ * @QMI_ENDIAN_BIG: Big endian.
+ *
+ * Type of endianness
+ */
+typedef enum {
+    QMI_ENDIAN_LITTLE = 0,
+    QMI_ENDIAN_BIG    = 1
+} QmiEndian;
+
+/* Reading/Writing integer variables */
+
+void qmi_utils_read_guint8_from_buffer  (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         guint8        *out);
+void qmi_utils_read_gint8_from_buffer   (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         gint8         *out);
+
+void qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         QmiEndian      endian,
+                                         guint16       *out);
+void qmi_utils_read_gint16_from_buffer  (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         QmiEndian      endian,
+                                         gint16        *out);
+
+void qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         QmiEndian      endian,
+                                         guint32       *out);
+void qmi_utils_read_gint32_from_buffer  (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         QmiEndian      endian,
+                                         gint32        *out);
+
+void qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         QmiEndian      endian,
+                                         guint64       *out);
+void qmi_utils_read_gint64_from_buffer  (const guint8 **buffer,
+                                         guint16       *buffer_size,
+                                         QmiEndian      endian,
+                                         gint64        *out);
+
+void qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
+                                             guint16       *buffer_size,
+                                             guint          n_bytes,
+                                             QmiEndian      endian,
+                                             guint64       *out);
+
+void qmi_utils_write_guint8_to_buffer (guint8  **buffer,
+                                       guint16  *buffer_size,
+                                       guint8   *in);
+void qmi_utils_write_gint8_to_buffer  (guint8  **buffer,
+                                       guint16  *buffer_size,
+                                       gint8    *in);
+
+void qmi_utils_write_guint16_to_buffer (guint8  **buffer,
+                                        guint16  *buffer_size,
+                                        QmiEndian endian,
+                                        guint16  *in);
+void qmi_utils_write_gint16_to_buffer  (guint8  **buffer,
+                                        guint16  *buffer_size,
+                                        QmiEndian endian,
+                                        gint16   *in);
+
+void qmi_utils_write_guint32_to_buffer (guint8  **buffer,
+                                        guint16  *buffer_size,
+                                        QmiEndian endian,
+                                        guint32  *in);
+void qmi_utils_write_gint32_to_buffer  (guint8  **buffer,
+                                        guint16  *buffer_size,
+                                        QmiEndian endian,
+                                        gint32   *in);
+
+void qmi_utils_write_guint64_to_buffer (guint8  **buffer,
+                                        guint16  *buffer_size,
+                                        QmiEndian endian,
+                                        guint64  *in);
+void qmi_utils_write_gint64_to_buffer  (guint8  **buffer,
+                                        guint16  *buffer_size,
+                                        QmiEndian endian,
+                                        gint64   *in);
+
+void qmi_utils_write_sized_guint_to_buffer (guint8  **buffer,
+                                            guint16  *buffer_size,
+                                            guint     n_bytes,
+                                            QmiEndian endian,
+                                            guint64  *in);
+
+/* Reading/Writing string variables */
+
+void qmi_utils_read_string_from_buffer (const guint8 **buffer,
+                                        guint16       *buffer_size,
+                                        guint8         length_prefix_size,
+                                        guint16        max_size,
+                                        gchar        **out);
+void qmi_utils_write_string_to_buffer  (guint8      **buffer,
+                                        guint16      *buffer_size,
+                                        guint8        length_prefix_size,
+                                        const gchar  *in);
+
+void qmi_utils_read_fixed_size_string_from_buffer (const guint8 **buffer,
+                                                   guint16       *buffer_size,
+                                                   guint16        fixed_size,
+                                                   gchar         *out);
+void qmi_utils_write_fixed_size_string_to_buffer  (guint8      **buffer,
+                                                   guint16      *buffer_size,
+                                                   guint16       fixed_size,
+                                                   const gchar  *in);
+
+/* Enabling/Disabling traces */
+gboolean qmi_utils_get_traces_enabled (void);
+void     qmi_utils_set_traces_enabled (gboolean enabled);
+
+/* Other private methods */
+
+#if defined (LIBQMI_GLIB_COMPILATION)
+G_GNUC_INTERNAL
+gchar *__qmi_utils_str_hex (gconstpointer mem,
+                            gsize size,
+                            gchar delimiter);
+#endif
+
+G_END_DECLS
+
+#endif /* _LIBQMI_GLIB_QMI_UTILS_H_ */
diff --git a/src/libqmi-glib/qmi-version.h.in b/src/libqmi-glib/qmi-version.h.in
new file mode 100644
index 0000000..22dda01
--- /dev/null
+++ b/src/libqmi-glib/qmi-version.h.in
@@ -0,0 +1,69 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301 USA.
+ *
+ * Copyright (C) 2013 Lanedo GmbH
+ */
+
+#ifndef _QMI_VERSION_H_
+#define _QMI_VERSION_H_
+
+/**
+ * SECTION:qmi-version
+ * @short_description: Version information in the API.
+ *
+ * This section defines types that are used to identify the libqmi-glib version.
+ **/
+
+/**
+ * QMI_MAJOR_VERSION:
+ *
+ * Evaluates to the major version number of libqmi-glib which this source
+ * is compiled against.
+ */
+#define QMI_MAJOR_VERSION (@QMI_MAJOR_VERSION@)
+
+/**
+ * QMI_MINOR_VERSION:
+ *
+ * Evaluates to the minor version number of libqmi-glib which this source
+ * is compiled against.
+ */
+#define QMI_MINOR_VERSION (@QMI_MINOR_VERSION@)
+
+/**
+ * QMI_MICRO_VERSION:
+ *
+ * Evaluates to the micro version number of libqmi-glib which this source
+ * compiled against.
+ */
+#define QMI_MICRO_VERSION (@QMI_MICRO_VERSION@)
+
+/**
+ * QMI_CHECK_VERSION:
+ * @major: major version (e.g. 1 for version 1.2.5)
+ * @minor: minor version (e.g. 2 for version 1.2.5)
+ * @micro: micro version (e.g. 5 for version 1.2.5)
+ *
+ * Returns: %TRUE if the version of the libqmi-glib header files
+ * is the same as or newer than the passed-in version.
+ */
+#define QMI_CHECK_VERSION(major,minor,micro)                         \
+    (QMI_MAJOR_VERSION > (major) ||                                  \
+     (QMI_MAJOR_VERSION == (major) && QMI_MINOR_VERSION > (minor)) || \
+     (QMI_MAJOR_VERSION == (major) && QMI_MINOR_VERSION == (minor) && QMI_MICRO_VERSION >= (micro)))
+
+#endif /* _QMI_VERSION_H_ */
diff --git a/src/libqmi-glib/test/Makefile.am b/src/libqmi-glib/test/Makefile.am
new file mode 100644
index 0000000..4d48e4d
--- /dev/null
+++ b/src/libqmi-glib/test/Makefile.am
@@ -0,0 +1,36 @@
+include $(top_srcdir)/gtester.make
+
+noinst_PROGRAMS = \
+	test-utils \
+	test-message
+
+TEST_PROGS += $(noinst_PROGRAMS)
+
+
+test_utils_SOURCES = \
+	test-utils.c
+test_utils_CPPFLAGS = \
+	$(LIBQMI_GLIB_CFLAGS) \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/src/libqmi-glib \
+	-I$(top_srcdir)/src/libqmi-glib/generated \
+	-I$(top_builddir)/src/libqmi-glib \
+	-I$(top_builddir)/src/libqmi-glib/generated \
+	-DLIBQMI_GLIB_COMPILATION
+test_utils_LDADD = \
+	$(top_builddir)/src/libqmi-glib/libqmi-glib.la \
+	$(LIBQMI_GLIB_LIBS)
+
+test_message_SOURCES = \
+	test-message.c
+test_message_CPPFLAGS = \
+	$(LIBQMI_GLIB_CFLAGS) \
+	-I$(top_srcdir) \
+	-I$(top_srcdir)/src/libqmi-glib \
+	-I$(top_srcdir)/src/libqmi-glib/generated \
+	-I$(top_builddir)/src/libqmi-glib \
+	-I$(top_builddir)/src/libqmi-glib/generated \
+	-DLIBQMI_GLIB_COMPILATION
+test_message_LDADD = \
+	$(top_builddir)/src/libqmi-glib/libqmi-glib.la \
+	$(LIBQMI_GLIB_LIBS)
diff --git a/src/libqmi-glib/test/test-message.c b/src/libqmi-glib/test/test-message.c
new file mode 100644
index 0000000..86fed8a
--- /dev/null
+++ b/src/libqmi-glib/test/test-message.c
@@ -0,0 +1,150 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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:
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@gnu.org>
+ */
+
+#include <config.h>
+#include <glib-object.h>
+#include <string.h>
+#include "qmi-message.h"
+
+static void
+test_message_parse_common (const guint8 *buffer,
+                           guint buffer_len,
+                           guint n_expected_messages)
+{
+    GError *error = NULL;
+    GByteArray *array;
+    guint n_messages = 0;
+
+    array = g_byte_array_sized_new (buffer_len);
+    g_byte_array_append (array, buffer, buffer_len);
+
+    do {
+        QmiMessage *message;
+        gchar *printable;
+
+        message = qmi_message_new_from_raw (array, &error);
+        if (!message) {
+            if (error) {
+                if (n_messages < n_expected_messages)
+                    g_printerr ("error creating message from raw data: '%s'\n", error->message);
+                g_error_free (error);
+            }
+            break;
+        }
+
+        printable = qmi_message_get_printable (message, "");
+        g_print ("\n%s\n", printable);
+        g_free (printable);
+
+        n_messages++;
+        qmi_message_unref (message);
+    } while (array->len > 0);
+
+    g_assert_cmpuint (n_messages, ==, n_expected_messages);
+}
+
+static void
+test_message_parse_short (void)
+{
+    const guint8 buffer[] = {
+        0x01, 0x26, 0x00, 0x80, 0x03, 0x01, 0x02, 0x01, 0x00, 0x20, 0x00, 0x1a,
+        0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x9b,
+        0x05, 0x11, 0x04, 0x00, 0x01, 0x00, 0x66, 0x05
+    };
+
+    test_message_parse_common (buffer, sizeof (buffer), 0);
+}
+
+static void
+test_message_parse_complete (void)
+{
+    const guint8 buffer[] = {
+        0x01, 0x26, 0x00, 0x80, 0x03, 0x01, 0x02, 0x01, 0x00, 0x20, 0x00, 0x1a,
+        0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x9b,
+        0x05, 0x11, 0x04, 0x00, 0x01, 0x00, 0x65, 0x05, 0x12, 0x04, 0x00, 0x01,
+        0x00, 0x11, 0x05
+    };
+
+    test_message_parse_common (buffer, sizeof (buffer), 1);
+}
+
+static void
+test_message_parse_complete_and_short (void)
+{
+    const guint8 buffer[] = {
+        0x01, 0x26, 0x00, 0x80, 0x03, 0x01, 0x02, 0x01, 0x00, 0x20, 0x00, 0x1a,
+        0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x9b,
+        0x05, 0x11, 0x04, 0x00, 0x01, 0x00, 0x65, 0x05, 0x12, 0x04, 0x00, 0x01,
+        0x00, 0x11, 0x05, 0x01, 0x26, 0x00, 0x80, 0x03, 0x01, 0x02, 0x01, 0x00,
+        0x20, 0x00, 0x1a, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x02, 0x00, 0x9b, 0x05, 0x11, 0x04, 0x00, 0x01, 0x00, 0x66, 0x05
+    };
+
+    test_message_parse_common (buffer, sizeof (buffer), 1);
+}
+
+static void
+test_message_parse_complete_and_complete (void)
+{
+    const guint8 buffer[] = {
+        0x01, 0x26, 0x00, 0x80, 0x03, 0x01, 0x02, 0x01, 0x00, 0x20, 0x00, 0x1a,
+        0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x9b,
+        0x05, 0x11, 0x04, 0x00, 0x01, 0x00, 0x65, 0x05, 0x12, 0x04, 0x00, 0x01,
+        0x00, 0x11, 0x05, 0x01, 0x26, 0x00, 0x80, 0x03, 0x01, 0x02, 0x01, 0x00,
+        0x20, 0x00, 0x1a, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+        0x02, 0x00, 0x9b, 0x05, 0x11, 0x04, 0x00, 0x01, 0x00, 0x65, 0x05, 0x12,
+        0x04, 0x00, 0x01, 0x00, 0x11, 0x05
+    };
+
+    test_message_parse_common (buffer, sizeof (buffer), 2);
+}
+
+#if GLIB_CHECK_VERSION (2,34,0)
+static void
+test_message_parse_wrong_tlv (void)
+{
+    const guint8 buffer[] = {
+        0x01, 0x4F, 0x00, 0x80, 0x03, 0x03, 0x02, 0x01, 0x00, 0x24, 0x00, 0x43,
+        0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x04, 0x00, 0x02,
+        0x03, 0x00, 0x00, 0x1D, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1C, 0x02,
+        0x00, 0x00, 0x00, 0x15, 0x03, 0x00, 0x01, 0x05, 0x01, 0x12, 0x0E, 0x00,
+        0x36, 0x01, 0x04, 0x01, 0x09, 0x20, 0x54, 0x2D, 0x4D, 0x6F, 0x62, 0x69,
+        0x6C, 0x65, 0x11, 0x02, 0x00, 0x01, 0x05, 0x10, 0x01, 0x00, 0x01, 0x01,
+        0x06, 0x00, 0x01, 0x01, 0x01, 0x02, 0x01, 0x05
+    };
+
+    g_test_expect_message ("Qmi",
+                           G_LOG_LEVEL_WARNING,
+                           "Cannot read the '*' TLV: expected '*' bytes, but only got '*' bytes");
+    test_message_parse_common (buffer, sizeof (buffer), 1);
+    g_test_assert_expected_messages ();
+}
+#endif
+
+int main (int argc, char **argv)
+{
+    g_type_init ();
+    g_test_init (&argc, &argv, NULL);
+
+    g_test_add_func ("/libqmi-glib/message/parse/short",                 test_message_parse_short);
+    g_test_add_func ("/libqmi-glib/message/parse/complete",              test_message_parse_complete);
+    g_test_add_func ("/libqmi-glib/message/parse/complete-and-short",    test_message_parse_complete_and_short);
+    g_test_add_func ("/libqmi-glib/message/parse/complete-and-complete", test_message_parse_complete_and_complete);
+#if GLIB_CHECK_VERSION (2,34,0)
+    g_test_add_func ("/libqmi-glib/message/parse/wrong-tlv",             test_message_parse_wrong_tlv);
+#endif
+
+    return g_test_run ();
+}
diff --git a/src/libqmi-glib/test/test-utils.c b/src/libqmi-glib/test/test-utils.c
new file mode 100644
index 0000000..04f552f
--- /dev/null
+++ b/src/libqmi-glib/test/test-utils.c
@@ -0,0 +1,1265 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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:
+ *
+ * Copyright (C) 2012 Aleksander Morgado <aleksander@gnu.org>
+ */
+
+#include <glib-object.h>
+#include <string.h>
+#include "qmi-utils.h"
+
+static void
+test_utils_uint8 (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+
+    while (in_buffer_size) {
+        guint8 tmp;
+
+        qmi_utils_read_guint8_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_write_guint8_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int8 (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+
+    while (in_buffer_size) {
+        gint8 tmp;
+
+        qmi_utils_read_gint8_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_write_gint8_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint16_le (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static const guint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint16 tmp;
+
+        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint16_be (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
+    };
+    static const guint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint16 tmp;
+
+        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int16_le (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static const gint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint16 tmp;
+
+        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int16_be (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
+    };
+    static const gint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint16 tmp;
+
+        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint16_unaligned_le (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static guint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint16 tmp;
+
+        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_uint16_unaligned_be (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
+    };
+    static guint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint16 tmp;
+
+        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_int16_unaligned_le (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static gint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint16 tmp;
+
+        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_int16_unaligned_be (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x50, 0x0F, 0xE2, 0xEB, 0x00, 0xB6, 0x00, 0x00
+    };
+    static gint16 values[4] = {
+        0x500F, 0xE2EB, 0x00B6, 0x0000
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint16 tmp;
+
+        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_uint32_le (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static const guint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint32 tmp;
+
+        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint32_be (void)
+{
+    static const guint8 in_buffer[8] = {
+        0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
+    };
+    static const guint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint32 tmp;
+
+        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int32_le (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static const gint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint32 tmp;
+
+        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int32_be (void)
+{
+    static const guint8 in_buffer[8] = {
+        0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
+    };
+    static const gint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint32 tmp;
+
+        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint32_unaligned_le (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static guint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint32 tmp;
+
+        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_uint32_unaligned_be (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
+    };
+    static guint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint32 tmp;
+
+        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_int32_unaligned_le (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static gint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint32 tmp;
+
+        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_int32_unaligned_be (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0xE2, 0xEB, 0x50, 0x0F, 0x00, 0x00, 0x00, 0xB6
+    };
+    static gint32 values[2] = {
+        0xE2EB500F, 0x000000B6
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint32 tmp;
+
+        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_uint64_le (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static const guint64 values[1] = {
+        0x000000B6E2EB500FULL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint64 tmp;
+
+        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint64_be (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
+    };
+    static const guint64 values[1] = {
+        0x000000B6E2EB500FULL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint64 tmp;
+
+        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int64_le (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static const gint64 values[1] = {
+        0x000000B6E2EB500FLL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint64 tmp;
+
+        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_int64_be (void)
+{
+    static const guint8 in_buffer[8] = {
+        0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
+    };
+    static const gint64 values[1] = {
+        0x000000B6E2EB500FLL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint64 tmp;
+
+        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (in_buffer, out_buffer, sizeof (in_buffer)) == 0);
+}
+
+static void
+test_utils_uint64_unaligned_le (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static guint64 values[1] = {
+        0x000000B6E2EB500FULL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint64 tmp;
+
+        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_uint64_unaligned_be (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
+    };
+    static guint64 values[1] = {
+        0x000000B6E2EB500FULL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        guint64 tmp;
+
+        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpuint (tmp, ==, values[i++]);
+        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_int64_unaligned_le (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    static gint64 values[1] = {
+        0x000000B6E2EB500FLL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint64 tmp;
+
+        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+test_utils_int64_unaligned_be (void)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
+    };
+    static gint64 values[1] = {
+        0x000000B6E2EB500FLL
+    };
+    guint8 out_buffer[8] = { 0 };
+
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    while (in_buffer_size) {
+        gint64 tmp;
+
+        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_BIG, &tmp);
+        g_assert_cmpint (tmp, ==, values[i++]);
+        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_BIG, &tmp);
+    }
+
+    g_assert_cmpuint (out_buffer_size, ==, 0);
+    g_assert (memcmp (&in_buffer[1], out_buffer, sizeof (in_buffer) - 1) == 0);
+}
+
+static void
+common_test_utils_uint_sized_le (guint n_bytes)
+{
+    static const guint8 in_buffer[8] = {
+        0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    guint64 value = 0x000000B6E2EB500FULL;
+    guint8 expected_out_buffer[8] = { 0 };
+    guint8 out_buffer[8] = { 0 };
+
+    guint64 tmp;
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    /* Build expected intermediate value */
+    tmp = 0xFF;
+    for (i = 1; i < n_bytes; i++) {
+        tmp <<= 8;
+        tmp |= 0xFF;
+    }
+    value &= tmp;
+
+    /* Build expected output buffer */
+    memcpy (expected_out_buffer, in_buffer, n_bytes);
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
+    g_assert_cmpuint (tmp, ==, value);
+    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
+
+    g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
+    g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
+}
+
+static void
+test_utils_uint_sized_1_le (void)
+{
+    common_test_utils_uint_sized_le (1);
+}
+
+static void
+test_utils_uint_sized_2_le (void)
+{
+    common_test_utils_uint_sized_le (2);
+}
+
+static void
+test_utils_uint_sized_4_le (void)
+{
+    common_test_utils_uint_sized_le (4);
+}
+
+static void
+test_utils_uint_sized_8_le (void)
+{
+    common_test_utils_uint_sized_le (8);
+}
+
+static void
+common_test_utils_uint_sized_be (guint n_bytes)
+{
+    static const guint8 in_buffer[8] = {
+        0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
+    };
+    guint64 value = 0x000000B6E2EB500FULL;
+    guint8 expected_out_buffer[8] = { 0 };
+    guint8 out_buffer[8] = { 0 };
+    guint8 in_buffer_aux[8] = { 0 };
+
+    guint64 tmp;
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    /* Build expected intermediate value */
+    tmp = 0xFF;
+    for (i = 1; i < n_bytes; i++) {
+        tmp <<= 8;
+        tmp |= 0xFF;
+    }
+    value &= tmp;
+
+    /* In BIG ENDIAN buffers, let's read only the bytes we want, starting from
+     * the byte we want, not from the beginning of the input buffer. But we do
+     * want to be aligned while reading, so we copy the bytes to read to the
+     * beginning of an aux buffer */
+    g_assert (n_bytes <= sizeof (in_buffer));
+    memcpy (&in_buffer_aux[0], &in_buffer[sizeof (in_buffer) - n_bytes], n_bytes);
+
+    /* Build expected output buffer */
+    memcpy (&expected_out_buffer[0], &in_buffer_aux[0], n_bytes);
+
+    in_buffer_size = sizeof (in_buffer);
+    in_buffer_walker = &in_buffer_aux[0];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+
+    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
+    g_assert_cmpuint (tmp, ==, value);
+    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
+
+    g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
+    if (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) != 0) {
+        g_print ("OUTPUT: %x, %x, %x, %x, %x, %x, %x, %x\n",
+                 out_buffer[0], out_buffer[1], out_buffer[2], out_buffer[3],
+                 out_buffer[4], out_buffer[5], out_buffer[6], out_buffer[7]);
+        g_print ("EXPECTED: %x, %x, %x, %x, %x, %x, %x, %x\n",
+                 expected_out_buffer[0], expected_out_buffer[1], expected_out_buffer[2], expected_out_buffer[3],
+                 expected_out_buffer[4], expected_out_buffer[5], expected_out_buffer[6], expected_out_buffer[7]);
+    }
+    g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
+}
+
+static void
+test_utils_uint_sized_1_be (void)
+{
+    common_test_utils_uint_sized_be (1);
+}
+
+static void
+test_utils_uint_sized_2_be (void)
+{
+    common_test_utils_uint_sized_be (2);
+}
+
+static void
+test_utils_uint_sized_4_be (void)
+{
+    common_test_utils_uint_sized_be (4);
+}
+
+static void
+test_utils_uint_sized_8_be (void)
+{
+    common_test_utils_uint_sized_be (8);
+}
+
+static void
+common_test_utils_uint_sized_unaligned_le (guint n_bytes)
+{
+    static const guint8 in_buffer[9] = {
+        0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
+    };
+    guint64 value = 0x000000B6E2EB500FULL;
+    guint8 expected_out_buffer[8] = { 0 };
+    guint8 out_buffer[8] = { 0 };
+
+    guint64 tmp;
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    /* Build expected intermediate value */
+    tmp = 0xFF;
+    for (i = 1; i < n_bytes; i++) {
+        tmp <<= 8;
+        tmp |= 0xFF;
+    }
+    value &= tmp;
+
+    /* Build expected output buffer */
+    memcpy (expected_out_buffer, &in_buffer[1], n_bytes);
+
+    in_buffer_size = sizeof (in_buffer) - 1;
+    in_buffer_walker = &in_buffer[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+
+    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
+    g_assert_cmpuint (tmp, ==, value);
+    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_LITTLE, &tmp);
+
+    g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
+    g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
+}
+
+static void
+test_utils_uint_sized_1_unaligned_le (void)
+{
+    common_test_utils_uint_sized_unaligned_le (1);
+}
+
+static void
+test_utils_uint_sized_2_unaligned_le (void)
+{
+    common_test_utils_uint_sized_unaligned_le (2);
+}
+
+static void
+test_utils_uint_sized_4_unaligned_le (void)
+{
+    common_test_utils_uint_sized_unaligned_le (4);
+}
+
+static void
+test_utils_uint_sized_8_unaligned_le (void)
+{
+    common_test_utils_uint_sized_unaligned_le (8);
+}
+
+static void
+common_test_utils_uint_sized_unaligned_be (guint n_bytes)
+{
+    static const guint8 in_buffer[8] = {
+        0x00, 0x00, 0x00, 0xB6, 0xE2, 0xEB, 0x50, 0x0F
+    };
+    guint64 value = 0x000000B6E2EB500FULL;
+    guint8 expected_out_buffer[8] = { 0 };
+    guint8 out_buffer[8] = { 0 };
+    guint8 in_buffer_aux[9] = { 0 };
+
+    guint64 tmp;
+    guint i;
+    guint16 in_buffer_size;
+    const guint8 *in_buffer_walker;
+    guint16 out_buffer_size;
+    guint8 *out_buffer_walker;
+
+    /* Build expected intermediate value */
+    tmp = 0xFF;
+    for (i = 1; i < n_bytes; i++) {
+        tmp <<= 8;
+        tmp |= 0xFF;
+    }
+    value &= tmp;
+
+    /* In BIG ENDIAN buffers, let's read only the bytes we want, starting from
+     * the byte we want, not from the beginning of the input buffer. But we do
+     * not want to be aligned while reading, so we copy the bytes to read to
+     * almost the beginning of an aux buffer */
+    g_assert (n_bytes <= (sizeof (in_buffer)));
+    memcpy (&in_buffer_aux[1], &in_buffer[sizeof (in_buffer) - n_bytes], n_bytes);
+
+    /* Build expected output buffer */
+    memcpy (expected_out_buffer, &in_buffer_aux[1], n_bytes);
+
+    in_buffer_size = sizeof (in_buffer_aux) - 1;
+    in_buffer_walker = &in_buffer_aux[1];
+    out_buffer_size = sizeof (out_buffer);
+    out_buffer_walker = &out_buffer[0];
+    i = 0;
+
+    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
+    g_assert_cmpuint (tmp, ==, value);
+    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, QMI_ENDIAN_BIG, &tmp);
+
+    g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
+    if (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) != 0) {
+        g_print ("OUTPUT: %x, %x, %x, %x, %x, %x, %x, %x\n",
+                 out_buffer[0], out_buffer[1], out_buffer[2], out_buffer[3],
+                 out_buffer[4], out_buffer[5], out_buffer[6], out_buffer[7]);
+        g_print ("EXPECTED: %x, %x, %x, %x, %x, %x, %x, %x\n",
+                 expected_out_buffer[0], expected_out_buffer[1], expected_out_buffer[2], expected_out_buffer[3],
+                 expected_out_buffer[4], expected_out_buffer[5], expected_out_buffer[6], expected_out_buffer[7]);
+    }
+    g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
+}
+
+static void
+test_utils_uint_sized_1_unaligned_be (void)
+{
+    common_test_utils_uint_sized_unaligned_be (1);
+}
+
+static void
+test_utils_uint_sized_2_unaligned_be (void)
+{
+    common_test_utils_uint_sized_unaligned_be (2);
+}
+
+static void
+test_utils_uint_sized_4_unaligned_be (void)
+{
+    common_test_utils_uint_sized_unaligned_be (4);
+}
+
+static void
+test_utils_uint_sized_8_unaligned_be (void)
+{
+    common_test_utils_uint_sized_unaligned_be (8);
+}
+
+int main (int argc, char **argv)
+{
+    g_type_init ();
+    g_test_init (&argc, &argv, NULL);
+
+    g_test_add_func ("/libqmi-glib/utils/uint8",  test_utils_uint8);
+    g_test_add_func ("/libqmi-glib/utils/int8",   test_utils_int8);
+
+    g_test_add_func ("/libqmi-glib/utils/uint16-LE",           test_utils_uint16_le);
+    g_test_add_func ("/libqmi-glib/utils/uint16-BE",           test_utils_uint16_be);
+    g_test_add_func ("/libqmi-glib/utils/int16-LE",            test_utils_int16_le);
+    g_test_add_func ("/libqmi-glib/utils/int16-BE",            test_utils_int16_be);
+    g_test_add_func ("/libqmi-glib/utils/uint16-unaligned-LE", test_utils_uint16_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint16-unaligned-Be", test_utils_uint16_unaligned_be);
+    g_test_add_func ("/libqmi-glib/utils/int16-unaligned-LE",  test_utils_int16_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/int16-unaligned-BE",  test_utils_int16_unaligned_be);
+
+    g_test_add_func ("/libqmi-glib/utils/uint32-LE",           test_utils_uint32_le);
+    g_test_add_func ("/libqmi-glib/utils/uint32-BE",           test_utils_uint32_be);
+    g_test_add_func ("/libqmi-glib/utils/int32-LE",            test_utils_int32_le);
+    g_test_add_func ("/libqmi-glib/utils/int32-BE",            test_utils_int32_be);
+    g_test_add_func ("/libqmi-glib/utils/uint32/unaligned-LE", test_utils_uint32_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint32/unaligned-BE", test_utils_uint32_unaligned_be);
+    g_test_add_func ("/libqmi-glib/utils/int32/unaligned-LE",  test_utils_int32_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/int32/unaligned-BE",  test_utils_int32_unaligned_be);
+
+    g_test_add_func ("/libqmi-glib/utils/uint64-LE",           test_utils_uint64_le);
+    g_test_add_func ("/libqmi-glib/utils/uint64-BE",           test_utils_uint64_be);
+    g_test_add_func ("/libqmi-glib/utils/int64-LE",            test_utils_int64_le);
+    g_test_add_func ("/libqmi-glib/utils/int64-BE",            test_utils_int64_be);
+    g_test_add_func ("/libqmi-glib/utils/uint64/unaligned-LE", test_utils_uint64_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint64/unaligned-BE", test_utils_uint64_unaligned_be);
+    g_test_add_func ("/libqmi-glib/utils/int64/unaligned-LE",  test_utils_int64_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/int64/unaligned-BE",  test_utils_int64_unaligned_be);
+
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-1-LE",           test_utils_uint_sized_1_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-2-LE",           test_utils_uint_sized_2_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-4-LE",           test_utils_uint_sized_4_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-8-LE",           test_utils_uint_sized_8_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-1-BE",           test_utils_uint_sized_1_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-2-BE",           test_utils_uint_sized_2_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-4-BE",           test_utils_uint_sized_4_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-8-BE",           test_utils_uint_sized_8_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-1-unaligned-LE", test_utils_uint_sized_1_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-2-unaligned-LE", test_utils_uint_sized_2_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-4-unaligned-LE", test_utils_uint_sized_4_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-8-unaligned-LE", test_utils_uint_sized_8_unaligned_le);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-1-unaligned-BE", test_utils_uint_sized_1_unaligned_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-2-unaligned-BE", test_utils_uint_sized_2_unaligned_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-4-unaligned-BE", test_utils_uint_sized_4_unaligned_be);
+    g_test_add_func ("/libqmi-glib/utils/uint-sized-8-unaligned-BE", test_utils_uint_sized_8_unaligned_be);
+
+    return g_test_run ();
+}