Imported Upstream version 0.4+git.20100624t180933.6e79d15upstream/0.4+git.20100624t180933.6e79d15

15 files changed, 2915 insertions, 0 deletions

diff --git a/libqcdm/src/Makefile.am b/libqcdm/src/Makefile.am
new file mode 100644
index 0000000..5cc0568
--- /dev/null
+++ b/libqcdm/src/Makefile.am
@@ -0,0 +1,42 @@
+noinst_LTLIBRARIES = libqcdm.la libqcdm-test.la
+
+
+libqcdm_la_CPPFLAGS = \
+	$(MM_CFLAGS)
+
+libqcdm_la_SOURCES = \
+	dm-commands.h \
+	nv-items.h \
+	com.c \
+	com.h \
+	commands.c \
+	commands.h \
+	error.c \
+	error.h \
+	result.c \
+	result.h \
+	result-private.h \
+	utils.c \
+	utils.h
+
+libqcdm_la_LIBADD = \
+	$(MM_LIBS)
+
+libqcdm_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libqcdm.ver \
+	-version-info "0:0:0"
+
+
+###########################################
+# Test library without symbol versioning
+###########################################
+
+libqcdm_test_la_CPPFLAGS = \
+	$(MM_CFLAGS)
+
+libqcdm_test_la_SOURCES = \
+	utils.c \
+	utils.h
+
+libqcdm_test_la_LIBADD = \
+	$(MM_LIBS)
+
diff --git a/libqcdm/src/com.c b/libqcdm/src/com.c
new file mode 100644
index 0000000..353103a
--- /dev/null
+++ b/libqcdm/src/com.c
@@ -0,0 +1,61 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <errno.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "com.h"
+#include "error.h"
+
+gboolean
+qcdm_port_setup (int fd, GError **error)
+{
+    struct termios stbuf;
+
+    g_type_init ();
+
+    errno = 0;
+    memset (&stbuf, 0, sizeof (stbuf));
+    if (tcgetattr (fd, &stbuf) != 0) {
+        g_set_error (error,
+                     QCDM_SERIAL_ERROR, QCDM_SERIAL_CONFIG_FAILED,
+                     "tcgetattr() error: %d", errno);
+    }
+
+    stbuf.c_cflag &= ~(CBAUD | CSIZE | CSTOPB | CLOCAL | PARENB);
+    stbuf.c_iflag &= ~(HUPCL | IUTF8 | IUCLC | ISTRIP | IXON | IXOFF | IXANY | ICRNL);
+    stbuf.c_oflag &= ~(OPOST | OCRNL | ONLCR | OLCUC | ONLRET);
+    stbuf.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOE | ECHOK | ECHONL);
+    stbuf.c_lflag &= ~(NOFLSH | XCASE | TOSTOP | ECHOPRT | ECHOCTL | ECHOKE);
+    stbuf.c_cc[VMIN] = 1;
+    stbuf.c_cc[VTIME] = 0;
+    stbuf.c_cc[VEOF] = 1;
+    stbuf.c_cflag |= (B115200 | CS8 | CREAD | 0 | 0);  /* No parity, 1 stop bit */
+
+    errno = 0;
+    if (tcsetattr (fd, TCSANOW, &stbuf) < 0) {
+        g_set_error (error,
+                     QCDM_SERIAL_ERROR, QCDM_SERIAL_CONFIG_FAILED,
+                     "tcsetattr() error: %d", errno);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
diff --git a/libqcdm/src/com.h b/libqcdm/src/com.h
new file mode 100644
index 0000000..97561d0
--- /dev/null
+++ b/libqcdm/src/com.h
@@ -0,0 +1,25 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_COM_H
+#define LIBQCDM_COM_H
+
+#include <glib.h>
+
+gboolean qcdm_port_setup (int fd, GError **error);
+
+#endif  /* LIBQCDM_COM_H */
diff --git a/libqcdm/src/commands.c b/libqcdm/src/commands.c
new file mode 100644
index 0000000..11a1a38
--- /dev/null
+++ b/libqcdm/src/commands.c
@@ -0,0 +1,1064 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+
+#include "commands.h"
+#include "error.h"
+#include "dm-commands.h"
+#include "nv-items.h"
+#include "result-private.h"
+#include "utils.h"
+
+
+/**********************************************************************/
+
+static guint8
+cdma_prev_to_qcdm (guint8 cdma)
+{
+    switch (cdma) {
+    case CDMA_PREV_IS_95:
+        return QCDM_CDMA_PREV_IS_95;
+    case CDMA_PREV_IS_95A:
+        return QCDM_CDMA_PREV_IS_95A;
+    case CDMA_PREV_IS_95A_TSB74:
+        return QCDM_CDMA_PREV_IS_95A_TSB74;
+    case CDMA_PREV_IS_95B_PHASE1:
+        return QCDM_CDMA_PREV_IS_95B_PHASE1;
+    case CDMA_PREV_IS_95B_PHASE2:
+        return QCDM_CDMA_PREV_IS_95B_PHASE2;
+    case CDMA_PREV_IS2000_REL0:
+        return QCDM_CDMA_PREV_IS2000_REL0;
+    case CDMA_PREV_IS2000_RELA:
+        return QCDM_CDMA_PREV_IS2000_RELA;
+    default:
+        break;
+    }
+    return QCDM_CDMA_PREV_UNKNOWN;
+}
+
+static guint8
+cdma_band_class_to_qcdm (guint8 cdma)
+{
+    switch (cdma) {
+    case CDMA_BAND_CLASS_0_CELLULAR_800:
+        return QCDM_CDMA_BAND_CLASS_0_CELLULAR_800;
+    case CDMA_BAND_CLASS_1_PCS:
+        return QCDM_CDMA_BAND_CLASS_1_PCS;
+    case CDMA_BAND_CLASS_2_TACS:
+        return QCDM_CDMA_BAND_CLASS_2_TACS;
+    case CDMA_BAND_CLASS_3_JTACS:
+        return QCDM_CDMA_BAND_CLASS_3_JTACS;
+    case CDMA_BAND_CLASS_4_KOREAN_PCS:
+        return QCDM_CDMA_BAND_CLASS_4_KOREAN_PCS;
+    case CDMA_BAND_CLASS_5_NMT450:
+        return QCDM_CDMA_BAND_CLASS_5_NMT450;
+    case CDMA_BAND_CLASS_6_IMT2000:
+        return QCDM_CDMA_BAND_CLASS_6_IMT2000;
+    case CDMA_BAND_CLASS_7_CELLULAR_700:
+        return QCDM_CDMA_BAND_CLASS_7_CELLULAR_700;
+    case CDMA_BAND_CLASS_8_1800:
+        return QCDM_CDMA_BAND_CLASS_8_1800;
+    case CDMA_BAND_CLASS_9_900:
+        return QCDM_CDMA_BAND_CLASS_9_900;
+    case CDMA_BAND_CLASS_10_SECONDARY_800:
+        return QCDM_CDMA_BAND_CLASS_10_SECONDARY_800;
+    case CDMA_BAND_CLASS_11_PAMR_400:
+        return QCDM_CDMA_BAND_CLASS_11_PAMR_400;
+    case CDMA_BAND_CLASS_12_PAMR_800:
+        return QCDM_CDMA_BAND_CLASS_12_PAMR_800;
+    default:
+        break;
+    }
+    return QCDM_CDMA_BAND_CLASS_UNKNOWN;
+}
+
+/**********************************************************************/
+
+/*
+ * utils_bin2hexstr
+ *
+ * Convert a byte-array into a hexadecimal string.
+ *
+ * Code originally by Alex Larsson <alexl@redhat.com> and
+ *  copyright Red Hat, Inc. under terms of the LGPL.
+ *
+ */
+static char *
+bin2hexstr (const guint8 *bytes, int len)
+{
+    static char hex_digits[] = "0123456789abcdef";
+    char *result;
+    int i;
+    gsize buflen = (len * 2) + 1;
+
+    g_return_val_if_fail (bytes != NULL, NULL);
+    g_return_val_if_fail (len > 0, NULL);
+    g_return_val_if_fail (len < 4096, NULL);   /* Arbitrary limit */
+
+    result = g_malloc0 (buflen);
+    for (i = 0; i < len; i++) {
+        result[2*i] = hex_digits[(bytes[i] >> 4) & 0xf];
+        result[2*i+1] = hex_digits[bytes[i] & 0xf];
+    }
+    result[buflen - 1] = '\0';
+    return result;
+}
+
+static gboolean
+check_command (const char *buf, gsize len, guint8 cmd, gsize min_len, GError **error)
+{
+    if (len < 1) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_MALFORMED_RESPONSE,
+                     "DM command response malformed (must be at least 1 byte in length)");
+        return FALSE;
+    }
+
+    switch (buf[0]) {
+    case DIAG_CMD_BAD_CMD:
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND,
+                     "DM command %d unknown or unimplemented by the device",
+                     cmd);
+        return FALSE;
+    case DIAG_CMD_BAD_PARM:
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "DM command %d contained invalid parameter",
+                     cmd);
+        return FALSE;
+    case DIAG_CMD_BAD_LEN:
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_LENGTH,
+                     "DM command %d was the wrong size",
+                     cmd);
+        return FALSE;
+    case DIAG_CMD_BAD_DEV:
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_NOT_ACCEPTED,
+                     "DM command %d was not accepted by the device",
+                     cmd);
+        return FALSE;
+    case DIAG_CMD_BAD_MODE:
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_MODE,
+                     "DM command %d not allowed in the current device mode",
+                     cmd);
+        return FALSE;
+    default:
+        break;
+    }
+
+    if (buf[0] != cmd) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_UNEXPECTED,
+                     "Unexpected DM command response (expected %d, got %d)",
+                     cmd, buf[0]);
+        return FALSE;
+    }
+
+    if (len < min_len) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_LENGTH,
+                     "DM command %d response not long enough (got %zu, expected "
+                     "at least %zu).", cmd, len, min_len);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+static gboolean
+check_nv_cmd (DMCmdNVReadWrite *cmd, guint16 nv_item, GError **error)
+{
+    guint16 cmd_item;
+
+    g_return_val_if_fail (cmd != NULL, FALSE);
+    g_return_val_if_fail ((cmd->code == DIAG_CMD_NV_READ) || (cmd->code == DIAG_CMD_NV_WRITE), FALSE);
+
+    /* NV read/write have a status byte at the end */
+    if (cmd->status != 0) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_NVCMD_FAILED,
+                        "The NV operation failed (status 0x%X).",
+                        GUINT16_FROM_LE (cmd->status));
+        return FALSE;
+    }
+
+    cmd_item = GUINT16_FROM_LE (cmd->nv_item);
+    if (cmd_item != nv_item) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_UNEXPECTED,
+                     "Unexpected DM NV command response (expected item %d, got "
+                     "item %d)", nv_item, cmd_item);
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_version_info_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[3];
+    DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_VERSION_INFO;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_version_info_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdVersionInfoRsp *rsp = (DMCmdVersionInfoRsp *) buf;
+    char tmp[12];
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_VERSION_INFO, sizeof (DMCmdVersionInfoRsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->comp_date) <= sizeof (tmp));
+    memcpy (tmp, rsp->comp_date, sizeof (rsp->comp_date));
+    qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_COMP_DATE, tmp);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->comp_time) <= sizeof (tmp));
+    memcpy (tmp, rsp->comp_time, sizeof (rsp->comp_time));
+    qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_COMP_TIME, tmp);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->rel_date) <= sizeof (tmp));
+    memcpy (tmp, rsp->rel_date, sizeof (rsp->rel_date));
+    qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_RELEASE_DATE, tmp);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->rel_time) <= sizeof (tmp));
+    memcpy (tmp, rsp->rel_time, sizeof (rsp->rel_time));
+    qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_RELEASE_TIME, tmp);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->model) <= sizeof (tmp));
+    memcpy (tmp, rsp->model, sizeof (rsp->model));
+    qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_MODEL, tmp);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_esn_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[3];
+    DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_ESN;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_esn_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdEsnRsp *rsp = (DMCmdEsnRsp *) buf;
+    char *tmp;
+    guint8 swapped[4];
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_ESN, sizeof (DMCmdEsnRsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    /* Convert the ESN from binary to a hex string; it's LE so we have to
+     * swap it to get the correct ordering.
+     */
+    swapped[0] = rsp->esn[3];
+    swapped[1] = rsp->esn[2];
+    swapped[2] = rsp->esn[1];
+    swapped[3] = rsp->esn[0];
+
+    tmp = bin2hexstr (&swapped[0], sizeof (swapped));
+    qcdm_result_add_string (result, QCDM_CMD_ESN_ITEM_ESN, tmp);
+    g_free (tmp);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_cdma_status_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[3];
+    DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_STATUS;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_cdma_status_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdStatusRsp *rsp = (DMCmdStatusRsp *) buf;
+    char *tmp;
+    guint8 swapped[4];
+    guint32 tmp_num;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_STATUS, sizeof (DMCmdStatusRsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    /* Convert the ESN from binary to a hex string; it's LE so we have to
+     * swap it to get the correct ordering.
+     */
+    swapped[0] = rsp->esn[3];
+    swapped[1] = rsp->esn[2];
+    swapped[2] = rsp->esn[1];
+    swapped[3] = rsp->esn[0];
+
+    tmp = bin2hexstr (&swapped[0], sizeof (swapped));
+    qcdm_result_add_string (result, QCDM_CMD_CDMA_STATUS_ITEM_ESN, tmp);
+    g_free (tmp);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->rf_mode);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE, tmp_num);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->cdma_rx_state);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE, tmp_num);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->entry_reason);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON, tmp_num);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->curr_chan);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL, tmp_num);
+
+    qcdm_result_add_uint8 (result, QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL, rsp->cdma_code_chan);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->pilot_base);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE, tmp_num);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->sid);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_SID, tmp_num);
+
+    tmp_num = (guint32) GUINT16_FROM_LE (rsp->nid);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_NID, tmp_num);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_sw_version_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[3];
+    DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_SW_VERSION;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_sw_version_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdSwVersionRsp *rsp = (DMCmdSwVersionRsp *) buf;
+    char tmp[25];
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_SW_VERSION, sizeof (*rsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->version) <= sizeof (tmp));
+    memcpy (tmp, rsp->version, sizeof (rsp->version));
+    qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_VERSION, tmp);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->comp_date) <= sizeof (tmp));
+    memcpy (tmp, rsp->comp_date, sizeof (rsp->comp_date));
+    qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_COMP_DATE, tmp);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (rsp->comp_time) <= sizeof (tmp));
+    memcpy (tmp, rsp->comp_time, sizeof (rsp->comp_time));
+    qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_COMP_TIME, tmp);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_pilot_sets_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[3];
+    DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_PILOT_SETS;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+#define PILOT_SETS_CMD_ACTIVE_SET    "active-set"
+#define PILOT_SETS_CMD_CANDIDATE_SET "candidate-set"
+#define PILOT_SETS_CMD_NEIGHBOR_SET  "neighbor-set"
+
+static const char *
+set_num_to_str (guint32 num)
+{
+    if (num == QCDM_CMD_PILOT_SETS_TYPE_ACTIVE)
+        return PILOT_SETS_CMD_ACTIVE_SET;
+    if (num == QCDM_CMD_PILOT_SETS_TYPE_CANDIDATE)
+        return PILOT_SETS_CMD_CANDIDATE_SET;
+    if (num == QCDM_CMD_PILOT_SETS_TYPE_NEIGHBOR)
+        return PILOT_SETS_CMD_NEIGHBOR_SET;
+    return NULL;
+}
+
+QCDMResult *
+qcdm_cmd_pilot_sets_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdPilotSetsRsp *rsp = (DMCmdPilotSetsRsp *) buf;
+    GByteArray *array;
+    gsize sets_len;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_PILOT_SETS, sizeof (DMCmdPilotSetsRsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    sets_len = rsp->active_count * sizeof (DMCmdPilotSetsSet);
+    if (sets_len > 0) {
+        array = g_byte_array_sized_new (sets_len);
+        g_byte_array_append (array, (const guint8 *) &rsp->sets[0], sets_len);
+        qcdm_result_add_boxed (result, PILOT_SETS_CMD_ACTIVE_SET, G_TYPE_BYTE_ARRAY, array);
+    }
+
+    sets_len = rsp->candidate_count * sizeof (DMCmdPilotSetsSet);
+    if (sets_len > 0) {
+        array = g_byte_array_sized_new (sets_len);
+        g_byte_array_append (array, (const guint8 *) &rsp->sets[rsp->active_count], sets_len);
+        qcdm_result_add_boxed (result, PILOT_SETS_CMD_CANDIDATE_SET, G_TYPE_BYTE_ARRAY, array);
+    }
+
+    sets_len = rsp->neighbor_count * sizeof (DMCmdPilotSetsSet);
+    if (sets_len > 0) {
+        array = g_byte_array_sized_new (sets_len);
+        g_byte_array_append (array, (const guint8 *) &rsp->sets[rsp->active_count + rsp->candidate_count], sets_len);
+        qcdm_result_add_boxed (result, PILOT_SETS_CMD_NEIGHBOR_SET, G_TYPE_BYTE_ARRAY, array);
+    }
+
+    return result;
+}
+
+gboolean
+qcdm_cmd_pilot_sets_result_get_num (QCDMResult *result,
+                                    guint32 set_type,
+                                    guint32 *out_num)
+{
+    const char *set_name;
+    GByteArray *array = NULL;
+
+    g_return_val_if_fail (result != NULL, FALSE);
+
+    set_name = set_num_to_str (set_type);
+    g_return_val_if_fail (set_name != NULL, FALSE);
+
+    if (!qcdm_result_get_boxed (result, set_name, (gpointer) &array))
+        return FALSE;
+
+    *out_num = array->len / sizeof (DMCmdPilotSetsSet);
+    return TRUE;
+}
+
+gboolean
+qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result,
+                                      guint32 set_type,
+                                      guint32 num,
+                                      guint32 *out_pn_offset,
+                                      guint32 *out_ecio,
+                                      float *out_db)
+{
+    const char *set_name;
+    GByteArray *array = NULL;
+    DMCmdPilotSetsSet *set;
+
+    g_return_val_if_fail (result != NULL, FALSE);
+
+    set_name = set_num_to_str (set_type);
+    g_return_val_if_fail (set_name != NULL, FALSE);
+
+    if (!qcdm_result_get_boxed (result, set_name, (gpointer) &array))
+        return FALSE;
+
+    g_return_val_if_fail (num < array->len / sizeof (DMCmdPilotSetsSet), FALSE);
+
+    set = (DMCmdPilotSetsSet *) &array->data[num * sizeof (DMCmdPilotSetsSet)];
+    *out_pn_offset = set->pn_offset;
+    *out_ecio = set->ecio;
+    /* EC/IO is in units of -0.5 dB per the specs */
+    *out_db = (float) set->ecio * -0.5;
+    return TRUE;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_nv_get_mdn_new (char *buf, gsize len, guint8 profile, GError **error)
+{
+    char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
+    DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
+    DMNVItemMdn *req;
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_NV_READ;
+    cmd->nv_item = GUINT16_TO_LE (DIAG_NV_DIR_NUMBER);
+
+    req = (DMNVItemMdn *) &cmd->data[0];
+    req->profile = profile;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_nv_get_mdn_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
+    DMNVItemMdn *mdn;
+    char tmp[11];
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+        return NULL;
+
+    if (!check_nv_cmd (rsp, DIAG_NV_DIR_NUMBER, error))
+        return NULL;
+
+    mdn = (DMNVItemMdn *) &rsp->data[0];
+
+    result = qcdm_result_new ();
+
+    qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_MDN_ITEM_PROFILE, mdn->profile);
+
+    memset (tmp, 0, sizeof (tmp));
+    g_assert (sizeof (mdn->mdn) <= sizeof (tmp));
+    memcpy (tmp, mdn->mdn, sizeof (mdn->mdn));
+    qcdm_result_add_string (result, QCDM_CMD_NV_GET_MDN_ITEM_MDN, tmp);
+
+    return result;
+}
+
+/**********************************************************************/
+
+static gboolean
+roam_pref_validate (guint8 dm)
+{
+    if (   dm == DIAG_NV_ROAM_PREF_HOME_ONLY
+        || dm == DIAG_NV_ROAM_PREF_ROAM_ONLY
+        || dm == DIAG_NV_ROAM_PREF_AUTO)
+        return TRUE;
+    return FALSE;
+}
+
+gsize
+qcdm_cmd_nv_get_roam_pref_new (char *buf, gsize len, guint8 profile, GError **error)
+{
+    char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
+    DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
+    DMNVItemRoamPref *req;
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_NV_READ;
+    cmd->nv_item = GUINT16_TO_LE (DIAG_NV_ROAM_PREF);
+
+    req = (DMNVItemRoamPref *) &cmd->data[0];
+    req->profile = profile;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_nv_get_roam_pref_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
+    DMNVItemRoamPref *roam;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+        return NULL;
+
+    if (!check_nv_cmd (rsp, DIAG_NV_ROAM_PREF, error))
+        return NULL;
+
+    roam = (DMNVItemRoamPref *) &rsp->data[0];
+
+    if (!roam_pref_validate (roam->roam_pref)) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "Unknown roam preference 0x%X",
+                     roam->roam_pref);
+        return NULL;
+    }
+
+    result = qcdm_result_new ();
+    qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_PROFILE, roam->profile);
+    qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF, roam->roam_pref);
+
+    return result;
+}
+
+gsize
+qcdm_cmd_nv_set_roam_pref_new (char *buf,
+                               gsize len,
+                               guint8 profile,
+                               guint8 roam_pref,
+                               GError **error)
+{
+    char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
+    DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
+    DMNVItemRoamPref *req;
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    if (!roam_pref_validate (roam_pref)) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "Invalid roam preference %d", roam_pref);
+        return 0;
+    }
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_NV_WRITE;
+    cmd->nv_item = GUINT16_TO_LE (DIAG_NV_ROAM_PREF);
+
+    req = (DMNVItemRoamPref *) &cmd->data[0];
+    req->profile = profile;
+    req->roam_pref = roam_pref;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_nv_set_roam_pref_result (const char *buf, gsize len, GError **error)
+{
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error))
+        return NULL;
+
+    if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_ROAM_PREF, error))
+        return NULL;
+
+    return qcdm_result_new ();
+}
+
+/**********************************************************************/
+
+static gboolean
+mode_pref_validate (guint8 dm)
+{
+    if (   dm == DIAG_NV_MODE_PREF_1X_ONLY
+        || dm == DIAG_NV_MODE_PREF_HDR_ONLY
+        || dm == DIAG_NV_MODE_PREF_AUTO)
+        return TRUE;
+    return FALSE;
+}
+
+gsize
+qcdm_cmd_nv_get_mode_pref_new (char *buf, gsize len, guint8 profile, GError **error)
+{
+    char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
+    DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
+    DMNVItemModePref *req;
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_NV_READ;
+    cmd->nv_item = GUINT16_TO_LE (DIAG_NV_MODE_PREF);
+
+    req = (DMNVItemModePref *) &cmd->data[0];
+    req->profile = profile;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_nv_get_mode_pref_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
+    DMNVItemModePref *mode;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+        return NULL;
+
+    if (!check_nv_cmd (rsp, DIAG_NV_MODE_PREF, error))
+        return NULL;
+
+    mode = (DMNVItemModePref *) &rsp->data[0];
+
+    if (!mode_pref_validate (mode->mode_pref)) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "Unknown mode preference 0x%X",
+                     mode->mode_pref);
+        return NULL;
+    }
+
+    result = qcdm_result_new ();
+    qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_PROFILE, mode->profile);
+    qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF, mode->mode_pref);
+
+    return result;
+}
+
+gsize
+qcdm_cmd_nv_set_mode_pref_new (char *buf,
+                               gsize len,
+                               guint8 profile,
+                               guint8 mode_pref,
+                               GError **error)
+{
+    char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
+    DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
+    DMNVItemModePref *req;
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    if (!mode_pref_validate (mode_pref)) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "Invalid mode preference %d", mode_pref);
+        return 0;
+    }
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_NV_WRITE;
+    cmd->nv_item = GUINT16_TO_LE (DIAG_NV_MODE_PREF);
+
+    req = (DMNVItemModePref *) &cmd->data[0];
+    req->profile = profile;
+    req->mode_pref = mode_pref;
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_nv_set_mode_pref_result (const char *buf, gsize len, GError **error)
+{
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error))
+        return NULL;
+
+    if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_MODE_PREF, error))
+        return NULL;
+
+    return qcdm_result_new ();
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_cm_subsys_state_info_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[sizeof (DMCmdSubsysHeader) + 2];
+    DMCmdSubsysHeader *cmd = (DMCmdSubsysHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_SUBSYS;
+    cmd->subsys_id = DIAG_SUBSYS_CM;
+    cmd->subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_CM_STATE_INFO);
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_cm_subsys_state_info_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdSubsysCMStateInfoRsp *rsp = (DMCmdSubsysCMStateInfoRsp *) buf;
+    guint32 tmp_num;
+    guint32 roam_pref;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysCMStateInfoRsp), error))
+        return NULL;
+
+    roam_pref = (guint32) GUINT32_FROM_LE (rsp->roam_pref);
+    if (!roam_pref_validate (roam_pref)) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "Unknown roam preference 0x%X",
+                     roam_pref);
+        return NULL;
+    }
+
+    result = qcdm_result_new ();
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->call_state);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->oper_mode);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->system_mode);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->mode_pref);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->band_pref);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF, tmp_num);
+
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF, roam_pref);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->srv_domain_pref);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->acq_order_pref);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->hybrid_pref);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF, tmp_num);
+
+    tmp_num = (guint32) GUINT32_FROM_LE (rsp->network_sel_mode_pref);
+    qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF, tmp_num);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_hdr_subsys_state_info_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[sizeof (DMCmdSubsysHeader) + 2];
+    DMCmdSubsysHeader *cmd = (DMCmdSubsysHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_SUBSYS;
+    cmd->subsys_id = DIAG_SUBSYS_HDR;
+    cmd->subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_HDR_STATE_INFO);
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_hdr_subsys_state_info_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdSubsysHDRStateInfoRsp *rsp = (DMCmdSubsysHDRStateInfoRsp *) buf;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysHDRStateInfoRsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE, rsp->at_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE, rsp->session_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE, rsp->almp_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE, rsp->init_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE, rsp->idle_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE, rsp->connected_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE, rsp->route_update_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE, rsp->overhead_msg_state);
+    qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE, rsp->hdr_hybrid_mode);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_zte_subsys_status_new (char *buf, gsize len, GError **error)
+{
+    char cmdbuf[sizeof (DMCmdSubsysHeader) + 2];
+    DMCmdSubsysHeader *cmd = (DMCmdSubsysHeader *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->code = DIAG_CMD_SUBSYS;
+    cmd->subsys_id = DIAG_SUBSYS_ZTE;
+    cmd->subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_ZTE_STATUS);
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_zte_subsys_status_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdSubsysZteStatusRsp *rsp = (DMCmdSubsysZteStatusRsp *) buf;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysZteStatusRsp), error))
+        return NULL;
+
+    result = qcdm_result_new ();
+
+    qcdm_result_add_uint8 (result, QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR, rsp->signal_ind);
+
+    return result;
+}
+
+/**********************************************************************/
+
+gsize
+qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf,
+                                            gsize len,
+                                            guint8 chipset,
+                                            GError **error)
+{
+    char cmdbuf[sizeof (DMCmdSubsysNwSnapshotReq) + 2];
+    DMCmdSubsysNwSnapshotReq *cmd = (DMCmdSubsysNwSnapshotReq *) &cmdbuf[0];
+
+    g_return_val_if_fail (buf != NULL, 0);
+    g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+
+    /* Validate chipset */
+    if (chipset != QCDM_NW_CHIPSET_6500 && chipset != QCDM_NW_CHIPSET_6800) {
+        g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
+                     "Unknown Novatel chipset 0x%X",
+                     chipset);
+        return 0;
+    }
+
+    memset (cmd, 0, sizeof (*cmd));
+    cmd->hdr.code = DIAG_CMD_SUBSYS;
+    switch (chipset) {
+    case QCDM_NW_CHIPSET_6500:
+        cmd->hdr.subsys_id = DIAG_SUBSYS_NW_CONTROL_6500;
+        break;
+    case QCDM_NW_CHIPSET_6800:
+        cmd->hdr.subsys_id = DIAG_SUBSYS_NW_CONTROL_6800;
+        break;
+    default:
+        g_assert_not_reached ();
+    }
+    cmd->hdr.subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT);
+    cmd->technology = DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_CDMA_EVDO;
+    cmd->snapshot_mask = GUINT32_TO_LE (0xFFFF);
+
+    return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
+}
+
+QCDMResult *
+qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf, gsize len, GError **error)
+{
+    QCDMResult *result = NULL;
+    DMCmdSubsysNwSnapshotRsp *rsp = (DMCmdSubsysNwSnapshotRsp *) buf;
+    DMCmdSubsysNwSnapshotCdma *cdma = (DMCmdSubsysNwSnapshotCdma *) &rsp->data;
+    guint32 num;
+    guint8 num8;
+
+    g_return_val_if_fail (buf != NULL, NULL);
+
+    if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysNwSnapshotRsp), error))
+        return NULL;
+
+    /* FIXME: check response_code when we know what it means */
+
+    result = qcdm_result_new ();
+
+    num = GUINT32_FROM_LE (cdma->rssi);
+    qcdm_result_add_uint32 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI, num);
+
+    num8 = cdma_prev_to_qcdm (cdma->prev);
+    qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV, num8);
+
+    num8 = cdma_band_class_to_qcdm (cdma->band_class);
+    qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS, num8);
+
+    qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI, cdma->eri);
+
+    num8 = QCDM_HDR_REV_UNKNOWN;
+    switch (cdma->hdr_rev) {
+    case 0:
+        num8 = QCDM_HDR_REV_0;
+        break;
+    case 1:
+        num8 = QCDM_HDR_REV_A;
+        break;
+    default:
+        break;
+    }
+    qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, num8);
+
+    return result;
+}
+
+/**********************************************************************/
+
diff --git a/libqcdm/src/commands.h b/libqcdm/src/commands.h
new file mode 100644
index 0000000..75e83a7
--- /dev/null
+++ b/libqcdm/src/commands.h
@@ -0,0 +1,437 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_COMMANDS_H
+#define LIBQCDM_COMMANDS_H
+
+#include <glib.h>
+
+#include "result.h"
+
+/**********************************************************************/
+
+/* Generic enums */
+
+enum {
+    QCDM_CDMA_PREV_UNKNOWN       = 0,
+    QCDM_CDMA_PREV_IS_95         = 1, /* and J_STD008 */
+    QCDM_CDMA_PREV_IS_95A        = 2,
+    QCDM_CDMA_PREV_IS_95A_TSB74  = 3,
+    QCDM_CDMA_PREV_IS_95B_PHASE1 = 4,
+    QCDM_CDMA_PREV_IS_95B_PHASE2 = 5,
+    QCDM_CDMA_PREV_IS2000_REL0   = 6,
+    QCDM_CDMA_PREV_IS2000_RELA   = 7
+};
+
+enum {
+    QCDM_CDMA_BAND_CLASS_UNKNOWN          = 0,
+    QCDM_CDMA_BAND_CLASS_0_CELLULAR_800   = 1,  /* US cellular 850MHz */
+    QCDM_CDMA_BAND_CLASS_1_PCS            = 2,  /* US PCS 1900MHz */
+    QCDM_CDMA_BAND_CLASS_2_TACS           = 3,
+    QCDM_CDMA_BAND_CLASS_3_JTACS          = 4,  /* Japanese TACS */
+    QCDM_CDMA_BAND_CLASS_4_KOREAN_PCS     = 5,
+    QCDM_CDMA_BAND_CLASS_5_NMT450         = 6,
+    QCDM_CDMA_BAND_CLASS_6_IMT2000        = 7,  /* 2100HMz */
+    QCDM_CDMA_BAND_CLASS_7_CELLULAR_700   = 8,
+    QCDM_CDMA_BAND_CLASS_8_1800           = 9,
+    QCDM_CDMA_BAND_CLASS_9_900            = 10,
+    QCDM_CDMA_BAND_CLASS_10_SECONDARY_800 = 11,
+    QCDM_CDMA_BAND_CLASS_11_PAMR_400      = 12,
+    QCDM_CDMA_BAND_CLASS_12_PAMR_800      = 13
+};
+
+enum {
+    QCDM_HDR_REV_UNKNOWN = 0x00,
+    QCDM_HDR_REV_0 = 0x01,
+    QCDM_HDR_REV_A = 0x02
+};
+
+/**********************************************************************/
+
+#define QCDM_CMD_VERSION_INFO_ITEM_COMP_DATE "comp-date"
+#define QCDM_CMD_VERSION_INFO_ITEM_COMP_TIME "comp-time"
+#define QCDM_CMD_VERSION_INFO_ITEM_RELEASE_DATE "release-date"
+#define QCDM_CMD_VERSION_INFO_ITEM_RELEASE_TIME "release-time"
+#define QCDM_CMD_VERSION_INFO_ITEM_MODEL "model"
+
+gsize       qcdm_cmd_version_info_new    (char *buf,
+                                          gsize len,
+                                          GError **error);
+
+QCDMResult *qcdm_cmd_version_info_result (const char *buf,
+                                          gsize len,
+                                          GError **error);
+
+/**********************************************************************/
+
+#define QCDM_CMD_ESN_ITEM_ESN "esn"
+
+gsize       qcdm_cmd_esn_new    (char *buf,
+                                 gsize len,
+                                 GError **error);
+
+QCDMResult *qcdm_cmd_esn_result (const char *buf,
+                                 gsize len,
+                                 GError **error);
+
+/**********************************************************************/
+
+/* Values for QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE */
+enum {
+    QCDM_CMD_CDMA_STATUS_RF_MODE_ANALOG = 0,
+    QCDM_CMD_CDMA_STATUS_RF_MODE_CDMA_CELLULAR = 1,
+    QCDM_CMD_CDMA_STATUS_RF_MODE_CDMA_PCS = 2,
+    QCDM_CMD_CDMA_STATUS_RF_MODE_SLEEP = 3,
+    QCDM_CMD_CDMA_STATUS_RF_MODE_GPS = 4,
+    QCDM_CMD_CDMA_STATUS_RF_MODE_HDR = 5,
+};
+
+/* Values for QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE */
+enum {
+    QCDM_CMD_CDMA_STATUS_RX_STATE_ENTERING_CDMA = 0,
+    QCDM_CMD_CDMA_STATUS_RX_STATE_SYNC_CHANNEL = 1,
+    QCDM_CMD_CDMA_STATUS_RX_STATE_PAGING_CHANNEL = 2,
+    QCDM_CMD_CDMA_STATUS_RX_STATE_TRAFFIC_CHANNEL_INIT = 3,
+    QCDM_CMD_CDMA_STATUS_RX_STATE_TRAFFIC_CHANNEL = 4,
+    QCDM_CMD_CDMA_STATUS_RX_STATE_EXITING_CDMA = 5,
+};
+
+#define QCDM_CMD_CDMA_STATUS_ITEM_ESN             "esn"
+#define QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE         "rf-mode"
+#define QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE        "rx-state"
+#define QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON    "entry-reason"
+#define QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL "current-channel"
+#define QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL    "code-channel"
+#define QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE      "pilot-base"
+#define QCDM_CMD_CDMA_STATUS_ITEM_SID             "sid"
+#define QCDM_CMD_CDMA_STATUS_ITEM_NID             "nid"
+
+gsize       qcdm_cmd_cdma_status_new    (char *buf,
+                                         gsize len,
+                                         GError **error);
+
+QCDMResult *qcdm_cmd_cdma_status_result (const char *buf,
+                                         gsize len,
+                                         GError **error);
+
+/**********************************************************************/
+
+/* NOTE: this command does not appear to be implemented in recent
+ * devices and probably returns (QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND).
+ */
+
+#define QCDM_CMD_SW_VERSION_ITEM_VERSION   "version"
+#define QCDM_CMD_SW_VERSION_ITEM_COMP_DATE "comp-date"
+#define QCDM_CMD_SW_VERSION_ITEM_COMP_TIME "comp-time"
+
+gsize       qcdm_cmd_sw_version_new    (char *buf,
+                                        gsize len,
+                                        GError **error);
+
+QCDMResult *qcdm_cmd_sw_version_result (const char *buf,
+                                        gsize len,
+                                        GError **error);
+
+/**********************************************************************/
+
+enum {
+    QCDM_CMD_PILOT_SETS_TYPE_UNKNOWN = 0,
+    QCDM_CMD_PILOT_SETS_TYPE_ACTIVE = 1,
+    QCDM_CMD_PILOT_SETS_TYPE_CANDIDATE = 2,
+    QCDM_CMD_PILOT_SETS_TYPE_NEIGHBOR = 3,
+};
+
+gsize       qcdm_cmd_pilot_sets_new    (char *buf,
+                                        gsize len,
+                                        GError **error);
+
+QCDMResult *qcdm_cmd_pilot_sets_result (const char *buf,
+                                        gsize len,
+                                        GError **error);
+
+gboolean    qcdm_cmd_pilot_sets_result_get_num   (QCDMResult *result,
+                                                  guint32 set_type,
+                                                  guint32 *out_num);
+
+gboolean    qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result,
+                                                  guint32 set_type,
+                                                  guint32 num,
+                                                  guint32 *out_pn_offset,
+                                                  guint32 *out_ecio,
+                                                  float *out_db);
+
+/**********************************************************************/
+
+#define QCDM_CMD_NV_GET_MDN_ITEM_PROFILE "profile"
+#define QCDM_CMD_NV_GET_MDN_ITEM_MDN "mdn"
+
+gsize       qcdm_cmd_nv_get_mdn_new    (char *buf,
+                                        gsize len,
+                                        guint8 profile,
+                                        GError **error);
+
+QCDMResult *qcdm_cmd_nv_get_mdn_result (const char *buf,
+                                        gsize len,
+                                        GError **error);
+
+/**********************************************************************/
+
+/* Values for QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF */
+enum {
+    QCDM_CMD_NV_ROAM_PREF_ITEM_ROAM_PREF_HOME_ONLY = 0x01,
+    QCDM_CMD_NV_ROAM_PREF_ITEM_ROAM_PREF_ROAM_ONLY = 0x06,
+    QCDM_CMD_NV_ROAM_PREF_ITEM_ROAM_PREF_AUTO = 0xFF,
+};
+
+#define QCDM_CMD_NV_GET_ROAM_PREF_ITEM_PROFILE   "profile"
+#define QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF "roam-pref"
+
+gsize       qcdm_cmd_nv_get_roam_pref_new    (char *buf,
+                                              gsize len,
+                                              guint8 profile,
+                                              GError **error);
+
+QCDMResult *qcdm_cmd_nv_get_roam_pref_result (const char *buf,
+                                              gsize len,
+                                              GError **error);
+
+gsize       qcdm_cmd_nv_set_roam_pref_new    (char *buf,
+                                              gsize len,
+                                              guint8 profile,
+                                              guint8 roam_pref,
+                                              GError **error);
+
+QCDMResult *qcdm_cmd_nv_set_roam_pref_result (const char *buf,
+                                              gsize len,
+                                              GError **error);
+
+/**********************************************************************/
+
+/* Values for QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF */
+enum {
+    QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF_AUTO = 0x04,
+    QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF_1X_ONLY = 0x09,
+    QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF_HDR_ONLY = 0x0A,
+};
+
+#define QCDM_CMD_NV_GET_MODE_PREF_ITEM_PROFILE   "profile"
+#define QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF "mode-pref"
+
+gsize       qcdm_cmd_nv_get_mode_pref_new    (char *buf,
+                                              gsize len,
+                                              guint8 profile,
+                                              GError **error);
+
+QCDMResult *qcdm_cmd_nv_get_mode_pref_result (const char *buf,
+                                              gsize len,
+                                              GError **error);
+
+gsize       qcdm_cmd_nv_set_mode_pref_new    (char *buf,
+                                              gsize len,
+                                              guint8 profile,
+                                              guint8 mode_pref,
+                                              GError **error);
+
+QCDMResult *qcdm_cmd_nv_set_mode_pref_result (const char *buf,
+                                              gsize len,
+                                              GError **error);
+
+/**********************************************************************/
+
+/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE */
+enum {
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_OPERATING_MODE_ONLINE = 5
+};
+
+/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE */
+enum {
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_NO_SERVICE = 0,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_AMPS = 1,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_CDMA = 2,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_GSM = 3,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_HDR = 4,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_WCDMA = 5,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_GPS = 6
+};
+
+/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF */
+enum {
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_HOME_ONLY = 0x01,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_ROAM_ONLY = 0x06,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_AUTO = 0xFF,
+};
+
+/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF */
+enum {
+    /* Note: not the same values as QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF has;
+     * AUTO really is 0x02 here, not 0x04 like the NV item value for AUTO.
+     */
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_DIGITAL_ONLY = 0x01,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_AUTO = 0x02,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_1X_ONLY = 0x09,
+    QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_HDR_ONLY = 0x0A,
+};
+
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE             "call-state"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE         "operating-mode"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE            "system-mode"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF              "mode-pref"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF              "band-pref"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF              "roam-pref"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF    "service-domain-pref"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF         "acq-order-pref"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF            "hybrid-pref"
+#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF "network-selection-pref"
+
+gsize       qcdm_cmd_cm_subsys_state_info_new    (char *buf,
+                                                  gsize len,
+                                                  GError **error);
+
+QCDMResult *qcdm_cmd_cm_subsys_state_info_result (const char *buf,
+                                                  gsize len,
+                                                  GError **error);
+
+/**********************************************************************/
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_INACTIVE = 0,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_ACQUISITION = 1,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_SYNC = 2,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_IDLE = 3,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_ACCESS = 4,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_CONNECTED = 5
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_CLOSED = 0,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_SETUP = 1,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_AT_INIT = 2,  /* initiated by Access Terminal */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_AN_INIT = 3,  /* initiated by Access Node */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_OPEN = 4,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_CLOSING = 5
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE (TIA-856-A section 9.2.1) */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_INACTIVE = 0,  /* initial state */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_INIT = 1,  /* terminal has yet to acquire network */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_IDLE = 2,  /* network acquired but no connection */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_CONNECTED = 3,  /* open connection to the network */
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE (TIA-856-A section 9.3.1) */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_INACTIVE = 0,  /* protocol waiting for ACTIVATE command */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_NET_DETERMINE = 1,  /* choosing a network to operate on */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_ACQUISITION = 2,  /* acquiring Forward Pilot Channel */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_SYNC = 3,  /* synchronizing to Control Channel */
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE (TIA-856-A section 9.4.1) */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_INACTIVE = 0,  /* protocol waiting for ACTIVATE command */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_SLEEP = 1,  /* sleeping */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_MONITOR = 2,  /* monitoring the Control Channel */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_SETUP = 3,  /* setting up a connection */
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE (TIA-856-A section 9.6.1) */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_INACTIVE = 0,  /* protocol waiting for ACTIVATE command */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_OPEN = 1,  /* connection is open */
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_CLOSING = 2,  /* connection is closed */
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE (TIA-856-A section 9.7.1) */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_INACTIVE = 0,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_IDLE = 1,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_CONNECTED = 2,
+};
+
+/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG (TIA-856-A section 9.9.1) */
+enum {
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_INIT = 0,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_INACTIVE = 1,
+    QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_ACTIVE = 2,
+};
+
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE           "at-state"  /* State of Access Terminal */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE      "session-state"  /* Current session state */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE         "almp-state"  /* Air Link Management Protocol (ALMP) state */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE         "init-state"  /* Initialization State Protocol (ISP) state */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE         "idle-state"  /* Idle State Protocol (IDP) state */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE    "connected-state"  /* Connected State Protocol (CSP) state */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE "route-update-state"  /* Route Update Protocol (RUP) state */
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE "overhead-msg-state"
+#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE    "hdr-hybrid-mode"
+
+gsize       qcdm_cmd_hdr_subsys_state_info_new    (char *buf,
+                                                   gsize len,
+                                                   GError **error);
+
+QCDMResult *qcdm_cmd_hdr_subsys_state_info_result (const char *buf,
+                                                   gsize len,
+                                                   GError **error);
+
+/**********************************************************************/
+
+#define QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR    "signal-indicator"
+
+gsize       qcdm_cmd_zte_subsys_status_new    (char *buf,
+                                               gsize len,
+                                               GError **error);
+
+QCDMResult *qcdm_cmd_zte_subsys_status_result (const char *buf,
+                                               gsize len,
+                                               GError **error);
+
+/**********************************************************************/
+
+#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI       "rssi"
+
+/* One of QCDM_CDMA_PREV_* */
+#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV       "prev"
+
+/* One of QCDM_CDMA_BAND_CLASS_* */
+#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS "band-class"
+
+#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI        "eri"
+
+/* One of QCDM_HDR_REV_* */
+#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV    "hdr-rev"
+
+enum {
+    QCDM_NW_CHIPSET_UNKNOWN = 0,
+    QCDM_NW_CHIPSET_6500 = 1,
+    QCDM_NW_CHIPSET_6800 = 2,
+};
+
+gsize       qcdm_cmd_nw_subsys_modem_snapshot_cdma_new    (char *buf,
+                                                           gsize len,
+                                                           guint8 chipset,
+                                                           GError **error);
+
+QCDMResult *qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf,
+                                                           gsize len,
+                                                           GError **error);
+
+/**********************************************************************/
+
+#endif  /* LIBQCDM_COMMANDS_H */
diff --git a/libqcdm/src/dm-commands.h b/libqcdm/src/dm-commands.h
new file mode 100644
index 0000000..cfc98f7
--- /dev/null
+++ b/libqcdm/src/dm-commands.h
@@ -0,0 +1,370 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_DM_COMMANDS_H
+#define LIBQCDM_DM_COMMANDS_H
+
+enum {
+    DIAG_CMD_VERSION_INFO = 0,  /* Version info */
+    DIAG_CMD_ESN          = 1,  /* ESN */
+    DIAG_CMD_PEEKB        = 2,  /* Peek byte */
+    DIAG_CMD_PEEKW        = 3,  /* Peek word */
+    DIAG_CMD_PEEKD        = 4,  /* Peek dword */
+    DIAG_CMD_POKEB        = 5,  /* Poke byte */
+    DIAG_CMD_POKEW        = 6,  /* Poke word */
+    DIAG_CMD_POKED        = 7,  /* Poke dword */
+    DIAG_CMD_OUTP         = 8,  /* Byte output */
+    DIAG_CMD_OUTPW        = 9,  /* Word output */
+    DIAG_CMD_INP          = 10, /* Byte input */
+    DIAG_CMD_INPW         = 11, /* Word input */
+    DIAG_CMD_STATUS       = 12, /* Station status */
+    DIAG_CMD_LOGMASK      = 15, /* Set logging mask */
+    DIAG_CMD_LOG          = 16, /* Log packet */
+    DIAG_CMD_NV_PEEK      = 17, /* Peek NV memory */
+    DIAG_CMD_NV_POKE      = 18, /* Poke NV memory */
+    DIAG_CMD_BAD_CMD      = 19, /* Invalid command (response) */
+    DIAG_CMD_BAD_PARM     = 20, /* Invalid parameter (response) */
+    DIAG_CMD_BAD_LEN      = 21, /* Invalid packet length (response) */
+    DIAG_CMD_BAD_DEV      = 22, /* Not accepted by the device (response) */
+    DIAG_CMD_BAD_MODE     = 24, /* Not allowed in this mode (response) */
+    DIAG_CMD_TAGRAPH      = 25, /* Info for TA power and voice graphs */
+    DIAG_CMD_MARKOV       = 26, /* Markov stats */
+    DIAG_CMD_MARKOV_RESET = 27, /* Reset Markov stats */
+    DIAG_CMD_DIAG_VER     = 28, /* Diagnostic Monitor version */
+    DIAG_CMD_TIMESTAMP    = 29, /* Return a timestamp */
+    DIAG_CMD_TA_PARM      = 30, /* Set TA parameters */
+    DIAG_CMD_MESSAGE      = 31, /* Request for msg report */
+    DIAG_CMD_HS_KEY       = 32, /* Handset emulation -- keypress */
+    DIAG_CMD_HS_LOCK      = 33, /* Handset emulation -- lock or unlock */
+    DIAG_CMD_HS_SCREEN    = 34, /* Handset emulation -- display request */
+    DIAG_CMD_PARM_SET     = 36, /* Parameter download */
+    DIAG_CMD_NV_READ      = 38, /* Read NV item */
+    DIAG_CMD_NV_WRITE     = 39, /* Write NV item */
+    DIAG_CMD_CONTROL      = 41, /* Mode change request */
+    DIAG_CMD_ERR_READ     = 42, /* Error record retreival */
+    DIAG_CMD_ERR_CLEAR    = 43, /* Error record clear */
+    DIAG_CMD_SER_RESET    = 44, /* Symbol error rate counter reset */
+    DIAG_CMD_SER_REPORT   = 45, /* Symbol error rate counter report */
+    DIAG_CMD_TEST         = 46, /* Run a specified test */
+    DIAG_CMD_GET_DIPSW    = 47, /* Retreive the current DIP switch setting */
+    DIAG_CMD_SET_DIPSW    = 48, /* Write new DIP switch setting */
+    DIAG_CMD_VOC_PCM_LB   = 49, /* Start/Stop Vocoder PCM loopback */
+    DIAG_CMD_VOC_PKT_LB   = 50, /* Start/Stop Vocoder PKT loopback */
+    DIAG_CMD_ORIG         = 53, /* Originate a call */
+    DIAG_CMD_END          = 54, /* End a call */
+    DIAG_CMD_SW_VERSION   = 56, /* Get software version */
+    DIAG_CMD_DLOAD        = 58, /* Switch to downloader */
+    DIAG_CMD_TMOB         = 59, /* Test Mode Commands and FTM commands*/
+    DIAG_CMD_STATE        = 63, /* Current state of the phone */
+    DIAG_CMD_PILOT_SETS   = 64, /* Return all current sets of pilots */
+    DIAG_CMD_SPC          = 65, /* Send the Service Programming Code to unlock */
+    DIAG_CMD_BAD_SPC_MODE = 66, /* Invalid NV read/write because SP is locked */
+    DIAG_CMD_PARM_GET2    = 67, /* (obsolete) */
+    DIAG_CMD_SERIAL_CHG   = 68, /* Serial mode change */
+    DIAG_CMD_PASSWORD     = 70, /* Send password to unlock secure operations */
+    DIAG_CMD_BAD_SEC_MODE = 71, /* Operation not allowed in this security state */
+    DIAG_CMD_PRL_WRITE         = 72,  /* Write PRL */
+    DIAG_CMD_PRL_READ          = 73,  /* Read PRL */
+    DIAG_CMD_SUBSYS            = 75,  /* Subsystem commands */
+    DIAG_CMD_FEATURE_QUERY     = 81,
+    DIAG_CMD_SMS_READ          = 83,  /* Read SMS message out of NV memory */
+    DIAG_CMD_SMS_WRITE         = 84,  /* Write SMS message into NV memory */
+    DIAG_CMD_SUP_FER           = 85,  /* Frame Error Rate info on multiple channels */
+    DIAG_CMD_SUP_WALSH_CODES   = 86,  /* Supplemental channel walsh codes */
+    DIAG_CMD_SET_MAX_SUP_CH    = 87,  /* Sets the maximum # supplemental channels */
+    DIAG_CMD_PARM_GET_IS95B    = 88,  /* Get parameters including SUPP and MUX2 */
+    DIAG_CMD_FS_OP             = 89,  /* Embedded File System (EFS) operations */
+    DIAG_CMD_AKEY_VERIFY       = 90,  /* AKEY Verification */
+    DIAG_CMD_HS_BMP_SCREEN     = 91,  /* Handset Emulation -- Bitmap screen */
+    DIAG_CMD_CONFIG_COMM       = 92,  /* Configure communications */
+    DIAG_CMD_EXT_LOGMASK       = 93,  /* Extended logmask for > 32 bits */
+    DIAG_CMD_EVENT_REPORT      = 96,  /* Static Event reporting */
+    DIAG_CMD_STREAMING_CONFIG  = 97,  /* Load balancing etc */
+    DIAG_CMD_PARM_RETRIEVE     = 98,  /* Parameter retrieval */
+    DIAG_CMD_STATUS_SNAPSHOT   = 99,  /* Status snapshot */
+    DIAG_CMD_RPC               = 100, /* Used for RPC */
+    DIAG_CMD_GET_PROPERTY      = 101,
+    DIAG_CMD_PUT_PROPERTY      = 102,
+    DIAG_CMD_GET_GUID          = 103, /* GUID requests */
+    DIAG_CMD_USER_CMD          = 104, /* User callbacks */
+    DIAG_CMD_GET_PERM_PROPERTY = 105,
+    DIAG_CMD_PUT_PERM_PROPERTY = 106,
+    DIAG_CMD_PERM_USER_CMD     = 107, /* Permanent user callbacks */
+    DIAG_CMD_GPS_SESS_CTRL     = 108, /* GPS session control */
+    DIAG_CMD_GPS_GRID          = 109, /* GPS search grid */
+    DIAG_CMD_GPS_STATISTICS    = 110,
+    DIAG_CMD_TUNNEL            = 111, /* Tunneling command code */
+    DIAG_CMD_RAM_RW            = 112, /* Calibration RAM control using DM */
+    DIAG_CMD_CPU_RW            = 113, /* Calibration CPU control using DM */
+    DIAG_CMD_SET_FTM_TEST_MODE = 114, /* Field (or Factory?) Test Mode */
+};
+
+/* Subsystem IDs used with DIAG_CMD_SUBSYS; these often obsolete many of
+ * the original DM commands.
+ */
+enum {
+    DIAG_SUBSYS_HDR             = 5,  /* High Data Rate (ie, EVDO) */
+    DIAG_SUBSYS_GPS             = 13,
+    DIAG_SUBSYS_SMS             = 14,
+    DIAG_SUBSYS_CM              = 15, /* Call manager */
+    DIAG_SUBSYS_NW_CONTROL_6500 = 50, /* for Novatel Wireless MSM6500-based devices */
+    DIAG_SUBSYS_ZTE             = 101, /* for ZTE EVDO devices */
+    DIAG_SUBSYS_NW_CONTROL_6800 = 250 /* for Novatel Wireless MSM6800-based devices */
+};
+
+/* HDR subsystem command codes */
+enum {
+    DIAG_SUBSYS_HDR_STATE_INFO  = 8, /* Gets EVDO state */
+};
+
+enum {
+    DIAG_SUBSYS_CM_STATE_INFO = 0, /* Gets Call Manager state */
+};
+
+/* NW_CONTROL subsystem command codes (only for Novatel Wireless devices) */
+enum {
+    DIAG_SUBSYS_NW_CONTROL_AT_REQUEST     = 3, /* AT commands via diag */
+    DIAG_SUBSYS_NW_CONTROL_AT_RESPONSE    = 4,
+    DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT = 7,
+    DIAG_SUBSYS_NW_CONTROL_ERI            = 8, /* Extended Roaming Indicator */
+    DIAG_SUBSYS_NW_CONTROL_PRL            = 12,
+};
+
+enum {
+    DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_CDMA_EVDO = 7,
+    DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_WCDMA = 20,
+};
+
+enum {
+    DIAG_SUBSYS_ZTE_STATUS = 0,
+};
+
+enum {
+    CDMA_PREV_UNKNOWN       = 0,
+    CDMA_PREV_IS_95         = 1, /* and J_STD008 */
+    CDMA_PREV_IS_95A        = 2,
+    CDMA_PREV_IS_95A_TSB74  = 3,
+    CDMA_PREV_IS_95B_PHASE1 = 4,
+    CDMA_PREV_IS_95B_PHASE2 = 5,
+    CDMA_PREV_IS2000_REL0   = 6,
+    CDMA_PREV_IS2000_RELA   = 7
+};
+
+enum {
+    CDMA_BAND_CLASS_0_CELLULAR_800   = 0,  /* US cellular 850MHz */
+    CDMA_BAND_CLASS_1_PCS            = 1,  /* US PCS 1900MHz */
+    CDMA_BAND_CLASS_2_TACS           = 2,
+    CDMA_BAND_CLASS_3_JTACS          = 3,  /* Japanese TACS */
+    CDMA_BAND_CLASS_4_KOREAN_PCS     = 4,
+    CDMA_BAND_CLASS_5_NMT450         = 5,
+    CDMA_BAND_CLASS_6_IMT2000        = 6,  /* 2100HMz */
+    CDMA_BAND_CLASS_7_CELLULAR_700   = 7,
+    CDMA_BAND_CLASS_8_1800           = 8,
+    CDMA_BAND_CLASS_9_900            = 9,
+    CDMA_BAND_CLASS_10_SECONDARY_800 = 10,
+    CDMA_BAND_CLASS_11_PAMR_400      = 11,
+    CDMA_BAND_CLASS_12_PAMR_800      = 12
+};
+
+/* Generic DM command header */
+struct DMCmdHeader {
+    guint8 code;
+} __attribute__ ((packed));
+typedef struct DMCmdHeader DMCmdHeader;
+
+/* DIAG_CMD_SUBSYS */
+struct DMCmdSubsysHeader {
+    guint8 code;
+    guint8 subsys_id;
+    guint16 subsys_cmd;
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysHeader DMCmdSubsysHeader;
+
+/* DIAG_CMD_NV_READ / DIAG_CMD_NV_WRITE */
+struct DMCmdNVReadWrite {
+    guint8 code;
+    guint16 nv_item;
+    guint8 data[128];
+    guint16 status;
+} __attribute__ ((packed));
+typedef struct DMCmdNVReadWrite DMCmdNVReadWrite;
+
+/* DIAG_CMD_VERSION_INFO */
+struct DMCmdVersionInfoRsp {
+    guint8 code;
+    char comp_date[11];
+    char comp_time[8];
+    char rel_date[11];
+    char rel_time[8];
+    char model[8];
+    guint8 scm;
+    guint8 mob_cai_rev;
+    guint8 mob_model;
+    guint16 mob_firmware_rev;
+    guint8 slot_cycle_index;
+    guint8 msm_ver;
+    guint8 _unknown;
+} __attribute__ ((packed));
+typedef struct DMCmdVersionInfoRsp DMCmdVersionInfoRsp;
+
+/* DIAG_CMD_ESN */
+struct DMCmdEsnRsp {
+    guint8 code;
+    guint8 esn[4];
+} __attribute__ ((packed));
+typedef struct DMCmdEsnRsp DMCmdEsnRsp;
+
+/* DIAG_CMD_STATUS */
+struct DMCmdStatusRsp {
+    guint8 code;
+    guint8 _unknown[3];
+    guint8 esn[4];
+    guint16 rf_mode;
+    guint8 min1_analog[4];
+    guint8 min1_cdma[4];
+    guint8 min2_analog[2];
+    guint8 min2_cdma[2];
+    guint8 _unknown1;
+    guint16 cdma_rx_state;
+    guint8 good_frames;
+    guint16 analog_corrected_frames;
+    guint16 analog_bad_frames;
+    guint16 analog_word_syncs;
+    guint16 entry_reason;
+    guint16 curr_chan;
+    guint8 cdma_code_chan;
+    guint16 pilot_base;
+    guint16 sid;
+    guint16 nid;
+    guint16 analog_locaid;
+    guint16 analog_rssi;
+    guint8 analog_power;
+} __attribute__ ((packed));
+typedef struct DMCmdStatusRsp DMCmdStatusRsp;
+
+/* DIAG_CMD_SW_VERSION */
+struct DMCmdSwVersionRsp {
+    guint8 code;
+    char version[20];
+    char comp_date[11];
+    char comp_time[8];
+} __attribute__ ((packed));
+typedef struct DMCmdSwVersionRsp DMCmdSwVersionRsp;
+
+/* DIAG_SUBSYS_CM_STATE_INFO subsys command */
+struct DMCmdSubsysCMStateInfoRsp {
+    DMCmdSubsysHeader header;
+    guint32 call_state;
+    guint32 oper_mode;
+    guint32 system_mode;
+    guint32 mode_pref;
+    guint32 band_pref;
+    guint32 roam_pref;
+    guint32 srv_domain_pref;
+    guint32 acq_order_pref;
+    guint32 hybrid_pref;
+    guint32 network_sel_mode_pref;
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysCMStateInfoRsp DMCmdSubsysCMStateInfoRsp;
+
+/* DIAG_SUBSYS_HDR_STATE_INFO subsys command */
+struct DMCmdSubsysHDRStateInfoRsp {
+    DMCmdSubsysHeader header;
+    guint8 at_state;
+    guint8 session_state;
+    guint8 almp_state;
+    guint8 init_state;
+    guint8 idle_state;
+    guint8 connected_state;
+    guint8 route_update_state;
+    guint8 overhead_msg_state;
+    guint8 hdr_hybrid_mode;
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysHDRStateInfoRsp DMCmdSubsysHDRStateInfoRsp;
+
+
+/* DIAG_SUBSYS_ZTE_STATUS subsys command */
+struct DMCmdSubsysZteStatusRsp {
+    DMCmdSubsysHeader header;
+    guint8 _unknown1[8];
+    guint8 signal_ind;
+    guint8 _unknown2;
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysZteStatusRsp DMCmdSubsysZteStatusRsp;
+
+/* DIAG_CMD_PILOT_SETS command */
+struct DMCmdPilotSetsSet {
+    guint16 pn_offset;
+    guint16 ecio;
+} __attribute__ ((packed));
+typedef struct DMCmdPilotSetsSet DMCmdPilotSetsSet;
+
+struct DMCmdPilotSetsRsp {
+    guint8 code;
+    guint16 pilot_inc;
+    guint8 active_count;
+    guint8 candidate_count;
+    guint8 neighbor_count;
+    DMCmdPilotSetsSet sets[52];
+} __attribute__ ((packed));
+typedef struct DMCmdPilotSetsRsp DMCmdPilotSetsRsp;
+
+/* DIAG_SUBSYS_NW_CONTROL_* subsys command */
+struct DMCmdSubsysNwSnapshotReq {
+    DMCmdSubsysHeader hdr;
+    guint8 technology;        /* DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_* */
+    guint32 snapshot_mask;
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysNwSnapshotReq DMCmdSubsysNwSnapshotReq;
+
+/* DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT response */
+struct DMCmdSubsysNwSnapshotRsp {
+    DMCmdSubsysHeader hdr;
+    guint8 response_code;
+    guint32 bitfield1;
+    guint32 bitfield2;
+    guint8 data[100];
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysNwSnapshotRsp DMCmdSubsysNwSnapshotRsp;
+
+struct DMCmdSubsysNwSnapshotCdma {
+    guint32 rssi;
+    guint32 battery_level;
+    guint8 call_info;
+    guint8 new_sms_ind;
+    guint8 missed_calls;
+    guint32 voicemail_ind;
+    guint8 pkt_call_ctrl_state;
+    guint8 mip_rrp_err_code;
+    guint8 cur_packet_zone_id;
+    guint8 prev;
+    guint8 band_class;
+    guint8 eri;
+    guint8 eri_alert_id;
+    guint32 cur_call_total_time;
+    guint32 cur_call_active_time;
+    guint32 cur_call_tx_ip_bytes;
+    guint32 cur_call_rx_ip_bytes;
+    guint8 connection_status;
+    guint16 dominant_pn;
+    guint8 wdisable_mask;
+    guint8 hdr_rev;
+} __attribute__ ((packed));
+typedef struct DMCmdSubsysNwSnapshotCdma DMCmdSubsysNwSnapshotCdma;
+
+#endif  /* LIBQCDM_DM_COMMANDS_H */
+
diff --git a/libqcdm/src/error.c b/libqcdm/src/error.c
new file mode 100644
index 0000000..e3b97a0
--- /dev/null
+++ b/libqcdm/src/error.c
@@ -0,0 +1,87 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "error.h"
+
+#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
+
+GQuark
+qcdm_serial_error_quark (void)
+{
+    static GQuark ret = 0;
+
+    if (ret == 0)
+        ret = g_quark_from_static_string ("qcdm-serial-error");
+
+    return ret;
+}
+
+GType
+qcdm_serial_error_get_type (void)
+{
+    static GType etype = 0;
+
+    if (etype == 0) {
+        static const GEnumValue values[] = {
+            ENUM_ENTRY (QCDM_SERIAL_CONFIG_FAILED, "SerialConfigFailed"),
+            { 0, 0, 0 }
+        };
+
+        etype = g_enum_register_static ("QcdmSerialError", values);
+    }
+
+    return etype;
+}
+
+/***************************************************************/
+
+GQuark
+qcdm_command_error_quark (void)
+{
+    static GQuark ret = 0;
+
+    if (ret == 0)
+        ret = g_quark_from_static_string ("qcdm-command-error");
+
+    return ret;
+}
+
+GType
+qcdm_command_error_get_type (void)
+{
+    static GType etype = 0;
+
+    if (etype == 0) {
+        static const GEnumValue values[] = {
+            ENUM_ENTRY (QCDM_COMMAND_MALFORMED_RESPONSE, "QcdmCommandMalformedResponse"),
+            ENUM_ENTRY (QCDM_COMMAND_UNEXPECTED, "QcdmCommandUnexpected"),
+            ENUM_ENTRY (QCDM_COMMAND_BAD_LENGTH, "QcdmCommandBadLength"),
+            ENUM_ENTRY (QCDM_COMMAND_BAD_COMMAND, "QcdmCommandBadCommand"),
+            ENUM_ENTRY (QCDM_COMMAND_BAD_PARAMETER, "QcdmCommandBadParameter"),
+            ENUM_ENTRY (QCDM_COMMAND_NOT_ACCEPTED, "QcdmCommandNotAccepted"),
+            ENUM_ENTRY (QCDM_COMMAND_BAD_MODE, "QcdmCommandBadMode"),
+            ENUM_ENTRY (QCDM_COMMAND_NVCMD_FAILED, "QcdmCommandNvCmdFailed"),
+            { 0, 0, 0 }
+        };
+
+        etype = g_enum_register_static ("QcdmCommandError", values);
+    }
+
+    return etype;
+}
+
+
diff --git a/libqcdm/src/error.h b/libqcdm/src/error.h
new file mode 100644
index 0000000..7a02ae2
--- /dev/null
+++ b/libqcdm/src/error.h
@@ -0,0 +1,53 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_ERROR_H
+#define LIBQCDM_ERROR_H
+
+#include <glib.h>
+#include <glib-object.h>
+
+enum {
+    QCDM_SERIAL_CONFIG_FAILED = 0,
+};
+
+#define QCDM_SERIAL_ERROR (qcdm_serial_error_quark ())
+#define QCDM_TYPE_SERIAL_ERROR (qcdm_serial_error_get_type ())
+
+GQuark qcdm_serial_error_quark    (void);
+GType  qcdm_serial_error_get_type (void);
+
+
+enum {
+    QCDM_COMMAND_MALFORMED_RESPONSE = 0,
+    QCDM_COMMAND_UNEXPECTED = 1,
+    QCDM_COMMAND_BAD_LENGTH = 2,
+    QCDM_COMMAND_BAD_COMMAND = 3,
+    QCDM_COMMAND_BAD_PARAMETER = 4,
+    QCDM_COMMAND_NOT_ACCEPTED = 5,
+    QCDM_COMMAND_BAD_MODE = 6,
+    QCDM_COMMAND_NVCMD_FAILED = 7,
+};
+
+#define QCDM_COMMAND_ERROR (qcdm_command_error_quark ())
+#define QCDM_TYPE_COMMAND_ERROR (qcdm_command_error_get_type ())
+
+GQuark qcdm_command_error_quark    (void);
+GType  qcdm_command_error_get_type (void);
+
+#endif  /* LIBQCDM_ERROR_H */
+
diff --git a/libqcdm/src/libqcdm.ver b/libqcdm/src/libqcdm.ver
new file mode 100644
index 0000000..b1567e2
--- /dev/null
+++ b/libqcdm/src/libqcdm.ver
@@ -0,0 +1,6 @@
+{
+global:
+	nm_vpn_connection_new;
+local:
+	*;
+};
diff --git a/libqcdm/src/nv-items.h b/libqcdm/src/nv-items.h
new file mode 100644
index 0000000..a0ca10a
--- /dev/null
+++ b/libqcdm/src/nv-items.h
@@ -0,0 +1,64 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_NV_ITEMS_H
+#define LIBQCDM_NV_ITEMS_H
+
+enum {
+    DIAG_NV_MODE_PREF  = 10,   /* Mode preference: 1x, HDR, auto */
+    DIAG_NV_DIR_NUMBER = 178,  /* Mobile Directory Number (MDN) */
+    DIAG_NV_ROAM_PREF  = 442,  /* Roaming preference */
+};
+
+
+/* Mode preference values */
+enum {
+    DIAG_NV_MODE_PREF_AUTO     = 0x04,
+    DIAG_NV_MODE_PREF_1X_ONLY  = 0x09,
+    DIAG_NV_MODE_PREF_HDR_ONLY = 0x0A,
+};
+
+/* DIAG_NV_MODE_PREF */
+struct DMNVItemModePref {
+    guint8 profile;
+    guint8 mode_pref;
+} __attribute__ ((packed));
+typedef struct DMNVItemModePref DMNVItemModePref;
+
+/* DIAG_NV_DIR_NUMBER */
+struct DMNVItemMdn {
+  guint8 profile; 
+  guint8 mdn[10]; 
+} __attribute__ ((packed));
+typedef struct DMNVItemMdn DMNVItemMdn;
+
+/* Roam preference values */
+enum {
+    DIAG_NV_ROAM_PREF_HOME_ONLY = 0x01,
+    DIAG_NV_ROAM_PREF_ROAM_ONLY = 0x06,
+    DIAG_NV_ROAM_PREF_AUTO      = 0xFF,
+};
+
+/* DIAG_NV_ROAM_PREF */
+struct DMNVItemRoamPref {
+    guint8 profile;
+    guint8 roam_pref;
+} __attribute__ ((packed));
+typedef struct DMNVItemRoamPref DMNVItemRoamPref;
+
+#endif  /* LIBQCDM_NV_ITEMS_H */
+
diff --git a/libqcdm/src/result-private.h b/libqcdm/src/result-private.h
new file mode 100644
index 0000000..0db63f5
--- /dev/null
+++ b/libqcdm/src/result-private.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_RESULT_PRIVATE_H
+#define LIBQCDM_RESULT_PRIVATE_H
+
+#include <glib.h>
+#include <glib-object.h>
+#include "result.h"
+
+QCDMResult *qcdm_result_new (void);
+
+/* For these functions, 'key' *must* be a constant, not allocated and freed */
+
+void qcdm_result_add_string (QCDMResult *result,
+                             const char *key,
+                             const char *str);
+
+void qcdm_result_add_uint8  (QCDMResult *result,
+                             const char *key,
+                             guint8 num);
+
+void qcdm_result_add_uint32 (QCDMResult *result,
+                             const char *key,
+                             guint32 num);
+
+void qcdm_result_add_boxed  (QCDMResult *result,
+                             const char *key,
+                             GType btype,
+                             gpointer boxed);
+
+gboolean qcdm_result_get_boxed (QCDMResult *result,
+                                const char *key,
+                                gpointer *out_val);
+
+#endif  /* LIBQCDM_RESULT_PRIVATE_H */
+
diff --git a/libqcdm/src/result.c b/libqcdm/src/result.c
new file mode 100644
index 0000000..2440478
--- /dev/null
+++ b/libqcdm/src/result.c
@@ -0,0 +1,248 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <string.h>
+#include <glib.h>
+
+#include "result.h"
+#include "result-private.h"
+#include "error.h"
+
+struct QCDMResult {
+    guint32 refcount;
+    GHashTable *hash;
+};
+
+
+static void
+gvalue_destroy (gpointer data)
+{
+    GValue *value = (GValue *) data;
+
+    g_value_unset (value);
+    g_slice_free (GValue, value);
+}
+
+QCDMResult *
+qcdm_result_new (void)
+{
+    QCDMResult *result;
+
+    g_type_init ();
+
+    result = g_malloc0 (sizeof (QCDMResult));
+    result->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
+                                          NULL, gvalue_destroy);
+    result->refcount = 1;
+    return result;
+}
+
+QCDMResult *
+qcdm_result_ref (QCDMResult *result)
+{
+    g_return_val_if_fail (result != NULL, NULL);
+    g_return_val_if_fail (result->refcount > 0, NULL);
+
+    result->refcount++;
+    return result;
+}
+
+void
+qcdm_result_unref (QCDMResult *result)
+{
+    g_return_if_fail (result != NULL);
+    g_return_if_fail (result->refcount > 0);
+
+    result->refcount--;
+    if (result->refcount == 0) {
+        g_hash_table_destroy (result->hash);
+        memset (result, 0, sizeof (QCDMResult));
+        g_free (result);
+    }
+}
+
+void
+qcdm_result_add_string (QCDMResult *result,
+                        const char *key,
+                        const char *str)
+{
+    GValue *val;
+
+    g_return_if_fail (result != NULL);
+    g_return_if_fail (result->refcount > 0);
+    g_return_if_fail (key != NULL);
+    g_return_if_fail (str != NULL);
+
+    val = g_slice_new0 (GValue);
+    g_value_init (val, G_TYPE_STRING);
+    g_value_set_string (val, str);
+
+    g_hash_table_insert (result->hash, (gpointer) key, val);
+}
+
+gboolean
+qcdm_result_get_string (QCDMResult *result,
+                        const char *key,
+                        const char **out_val)
+{
+    GValue *val;
+
+    g_return_val_if_fail (result != NULL, FALSE);
+    g_return_val_if_fail (result->refcount > 0, FALSE);
+    g_return_val_if_fail (key != NULL, FALSE);
+    g_return_val_if_fail (out_val != NULL, FALSE);
+    g_return_val_if_fail (*out_val == NULL, FALSE);
+
+    val = g_hash_table_lookup (result->hash, key);
+    if (!val)
+        return FALSE;
+
+    g_warn_if_fail (G_VALUE_HOLDS_STRING (val));
+    if (!G_VALUE_HOLDS_STRING (val))
+        return FALSE;
+
+    *out_val = g_value_get_string (val);
+    return TRUE;
+}
+
+void
+qcdm_result_add_uint8 (QCDMResult *result,
+                        const char *key,
+                        guint8 num)
+{
+    GValue *val;
+
+    g_return_if_fail (result != NULL);
+    g_return_if_fail (result->refcount > 0);
+    g_return_if_fail (key != NULL);
+
+    val = g_slice_new0 (GValue);
+    g_value_init (val, G_TYPE_UCHAR);
+    g_value_set_uchar (val, (unsigned char) num);
+
+    g_hash_table_insert (result->hash, (gpointer) key, val);
+}
+
+gboolean
+qcdm_result_get_uint8  (QCDMResult *result,
+                        const char *key,
+                        guint8 *out_val)
+{
+    GValue *val;
+
+    g_return_val_if_fail (result != NULL, FALSE);
+    g_return_val_if_fail (result->refcount > 0, FALSE);
+    g_return_val_if_fail (key != NULL, FALSE);
+    g_return_val_if_fail (out_val != NULL, FALSE);
+
+    val = g_hash_table_lookup (result->hash, key);
+    if (!val)
+        return FALSE;
+
+    g_warn_if_fail (G_VALUE_HOLDS_UCHAR (val));
+    if (!G_VALUE_HOLDS_UCHAR (val))
+        return FALSE;
+
+    *out_val = (guint8) g_value_get_uchar (val);
+    return TRUE;
+}
+
+void
+qcdm_result_add_uint32 (QCDMResult *result,
+                        const char *key,
+                        guint32 num)
+{
+    GValue *val;
+
+    g_return_if_fail (result != NULL);
+    g_return_if_fail (result->refcount > 0);
+    g_return_if_fail (key != NULL);
+
+    val = g_slice_new0 (GValue);
+    g_value_init (val, G_TYPE_UINT);
+    g_value_set_uint (val, num);
+
+    g_hash_table_insert (result->hash, (gpointer) key, val);
+}
+
+gboolean
+qcdm_result_get_uint32 (QCDMResult *result,
+                        const char *key,
+                        guint32 *out_val)
+{
+    GValue *val;
+
+    g_return_val_if_fail (result != NULL, FALSE);
+    g_return_val_if_fail (result->refcount > 0, FALSE);
+    g_return_val_if_fail (key != NULL, FALSE);
+    g_return_val_if_fail (out_val != NULL, FALSE);
+
+    val = g_hash_table_lookup (result->hash, key);
+    if (!val)
+        return FALSE;
+
+    g_warn_if_fail (G_VALUE_HOLDS_UINT (val));
+    if (!G_VALUE_HOLDS_UINT (val))
+        return FALSE;
+
+    *out_val = (guint32) g_value_get_uint (val);
+    return TRUE;
+}
+
+void
+qcdm_result_add_boxed (QCDMResult *result,
+                       const char *key,
+                       GType btype,
+                       gpointer boxed)
+{
+    GValue *val;
+
+    g_return_if_fail (result != NULL);
+    g_return_if_fail (result->refcount > 0);
+    g_return_if_fail (key != NULL);
+
+    val = g_slice_new0 (GValue);
+    g_value_init (val, btype);
+    g_value_set_static_boxed (val, boxed);
+
+    g_hash_table_insert (result->hash, (gpointer) key, val);
+}
+
+gboolean
+qcdm_result_get_boxed (QCDMResult *result,
+                       const char *key,
+                       gpointer *out_val)
+{
+    GValue *val;
+
+    g_return_val_if_fail (result != NULL, FALSE);
+    g_return_val_if_fail (result->refcount > 0, FALSE);
+    g_return_val_if_fail (key != NULL, FALSE);
+    g_return_val_if_fail (out_val != NULL, FALSE);
+
+    val = g_hash_table_lookup (result->hash, key);
+    if (!val)
+        return FALSE;
+
+    g_warn_if_fail (G_VALUE_HOLDS_BOXED (val));
+    if (!G_VALUE_HOLDS_BOXED (val))
+        return FALSE;
+
+    *out_val = g_value_get_boxed (val);
+    return TRUE;
+}
+
diff --git a/libqcdm/src/result.h b/libqcdm/src/result.h
new file mode 100644
index 0000000..4912b07
--- /dev/null
+++ b/libqcdm/src/result.h
@@ -0,0 +1,42 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBQCDM_RESULT_H
+#define LIBQCDM_RESULT_H
+
+#include <glib.h>
+
+typedef struct QCDMResult QCDMResult;
+
+gboolean qcdm_result_get_string (QCDMResult *result,
+                                 const char *key,
+                                 const char **out_val);
+
+gboolean qcdm_result_get_uint8  (QCDMResult *result,
+                                 const char *key,
+                                 guint8 *out_val);
+
+gboolean qcdm_result_get_uint32 (QCDMResult *result,
+                                 const char *key,
+                                 guint32 *out_val);
+
+QCDMResult *qcdm_result_ref     (QCDMResult *result);
+
+void        qcdm_result_unref   (QCDMResult *result);
+
+#endif  /* LIBQCDM_RESULT_H */
+
diff --git a/libqcdm/src/utils.c b/libqcdm/src/utils.c
new file mode 100644
index 0000000..b581548
--- /dev/null
+++ b/libqcdm/src/utils.c
@@ -0,0 +1,311 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <fcntl.h>
+#include <string.h>
+
+#include "utils.h"
+
+/* QCDM protocol frames are pseudo Async HDLC frames which end with a 3-byte
+ * trailer.  This trailer consists of the 16-bit CRC of the frame plus an ending
+ * "async control character" whose value is 0x7E.  The frame *and* the CRC are
+ * escaped before adding the trailing control character so that the control
+ * character (0x7E) and the escape marker (0x7D) are never seen in the frame.
+ */
+
+/* Table of CRCs for each possible byte, with a generator polynomial of 0x8408 */
+const guint16 crc_table[256] = {
+    0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
+    0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
+    0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
+    0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
+    0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
+    0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
+    0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
+    0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
+    0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
+    0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
+    0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
+    0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
+    0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
+    0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
+    0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
+    0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
+    0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
+    0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
+    0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
+    0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
+    0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
+    0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
+    0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
+    0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
+    0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
+    0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
+    0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
+    0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
+    0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
+    0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
+    0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
+    0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
+};
+
+/* Calculate the CRC for a buffer using a seed of 0xffff */
+guint16
+crc16 (const char *buffer, gsize len)
+{
+    guint16 crc = 0xffff;
+
+    while (len--)
+            crc = crc_table[(crc ^ *buffer++) & 0xff] ^ (crc >> 8);
+    return ~crc;
+}
+
+#define DIAG_ESC_CHAR     0x7D  /* Escape sequence 1st character value */
+#define DIAG_ESC_MASK     0x20  /* Escape sequence complement value */
+
+/* Performs DM escaping on inbuf putting the result into outbuf, and returns
+ * the final length of the buffer.
+ */
+gsize
+dm_escape (const char *inbuf,
+           gsize inbuf_len,
+           char *outbuf,
+           gsize outbuf_len)
+{
+    const char *src = inbuf;
+    char *dst = outbuf;
+    size_t i = inbuf_len;
+
+    g_return_val_if_fail (inbuf != NULL, 0);
+    g_return_val_if_fail (inbuf_len > 0, 0);
+    g_return_val_if_fail (outbuf != NULL, 0);
+    g_return_val_if_fail (outbuf_len > inbuf_len, 0);
+
+    /* Since escaping potentially doubles the # of bytes, short-circuit the
+     * length check if destination buffer is clearly large enough.  Note the
+     * 
+     */
+    if (outbuf_len <= inbuf_len << 1) {
+        size_t outbuf_required = inbuf_len + 1; /* +1 for the trailing control char */
+
+        /* Each escaped character takes up two bytes in the output buffer */
+        while (i--) {
+            if (*src == DIAG_CONTROL_CHAR || *src == DIAG_ESC_CHAR)
+                outbuf_required++;
+            src++;
+        }
+
+        if (outbuf_len < outbuf_required)
+            return 0;
+    }
+
+    /* Do the actual escaping.  Replace both the control character and
+     * the escape character in the source buffer with the following sequence:
+     *
+     * <escape_char> <src_byte ^ escape_mask>
+     */
+    src = inbuf;
+    i = inbuf_len;
+    while (i--) {
+        if (*src == DIAG_CONTROL_CHAR || *src == DIAG_ESC_CHAR) {
+            *dst++ = DIAG_ESC_CHAR;
+            *dst++ = *src ^ DIAG_ESC_MASK;
+        } else
+            *dst++ = *src;
+        src++;
+    }
+
+    return (dst - outbuf);
+}
+
+gsize
+dm_unescape (const char *inbuf,
+             gsize inbuf_len,
+             char *outbuf,
+             gsize outbuf_len,
+             gboolean *escaping)
+{
+    size_t i, outsize;
+
+    g_return_val_if_fail (inbuf_len > 0, 0);
+    g_return_val_if_fail (outbuf_len >= inbuf_len, 0);
+    g_return_val_if_fail (escaping != NULL, 0);
+
+    for (i = 0, outsize = 0; i < inbuf_len; i++) {
+        if (*escaping) {
+            outbuf[outsize++] = inbuf[i] ^ DIAG_ESC_MASK;
+            *escaping = FALSE;
+        } else if (inbuf[i] == DIAG_ESC_CHAR)
+            *escaping = TRUE;
+        else
+            outbuf[outsize++] = inbuf[i];
+
+        /* About to overrun output buffer size */
+        if (outsize >= outbuf_len)
+            return 0;
+    }
+
+    return outsize;
+}
+
+/**
+ * dm_encapsulate_buffer:
+ * @inbuf: buffer in which a valid QCDM packet exists
+ * @cmd_len: size of the QCDM packet contained in @inbuf
+ * @inbuf_len: total size of @inbuf itself (not just the packet)
+ * @outbuf: buffer in which to put the encapsulated QCDM packet
+ * @outbuf_len: total size of @outbuf
+ *
+ * Escapes and CRCs a QCDM packet, and finally adds the trailing control
+ * character that denotes the end of the QCDM packet.
+ *
+ * Returns: size of the encapsulated QCDM command writted to @outbuf.
+ **/
+gsize
+dm_encapsulate_buffer (char *inbuf,
+                       gsize cmd_len,
+                       gsize inbuf_len,
+                       char *outbuf,
+                       gsize outbuf_len)
+{
+    guint16 crc;
+    gsize escaped_len;
+
+    g_return_val_if_fail (inbuf != NULL, 0);
+    g_return_val_if_fail (cmd_len >= 1, 0);
+    g_return_val_if_fail (inbuf_len >= cmd_len + 2, 0); /* space for CRC */
+    g_return_val_if_fail (outbuf != NULL, 0);
+
+    /* Add the CRC */
+    crc = crc16 (inbuf, cmd_len);
+    inbuf[cmd_len++] = crc & 0xFF;
+    inbuf[cmd_len++] = (crc >> 8) & 0xFF;
+
+    escaped_len = dm_escape (inbuf, cmd_len, outbuf, outbuf_len);
+    g_return_val_if_fail (outbuf_len > escaped_len, 0);
+    outbuf[escaped_len++] = DIAG_CONTROL_CHAR;
+
+    return escaped_len;
+}
+
+/**
+ * dm_decapsulate_buffer:
+ * @inbuf: buffer in which to look for a QCDM packet
+ * @inbuf_len: length of valid data in @inbuf
+ * @outbuf: buffer in which to put decapsulated QCDM packet
+ * @outbuf_len: max size of @outbuf
+ * @out_decap_len: on success, size of the decapsulated QCDM packet
+ * @out_used: on either success or failure, amount of data used; caller should
+ *  discard this much data from @inbuf before the next call to this function
+ * @out_need_more: when TRUE, indicates that more data is required before
+ *  and determination about a valid QCDM packet can be made; caller should add
+ *  more data to @inbuf before calling this function again.
+ *
+ * Attempts to retrieve, unescape, and CRC-check a QCDM packet from the given
+ * buffer.
+ *
+ * Returns: FALSE on error (packet was invalid or malformed, or the CRC check
+ *  failed, etc) and places number of bytes to discard from @inbuf in @out_used.
+ *  When TRUE, either more data is required (in which case @out_need_more will
+ *  be TRUE), or a QCDM packet was successfully retrieved from @inbuf and the
+ *  decapsulated packet of length @out_decap_len was placed into @outbuf.  In
+ *  all cases the caller should advance the buffer by the number of bytes
+ *  returned in @out_used before calling this function again.
+ **/
+gboolean
+dm_decapsulate_buffer (const char *inbuf,
+                       gsize inbuf_len,
+                       char *outbuf,
+                       gsize outbuf_len,
+                       gsize *out_decap_len,
+                       gsize *out_used,
+                       gboolean *out_need_more)
+{
+    gboolean escaping = FALSE;
+    gsize i, pkt_len = 0, unesc_len;
+    guint16 crc, pkt_crc;
+
+    g_return_val_if_fail (inbuf != NULL, FALSE);
+    g_return_val_if_fail (outbuf != NULL, FALSE);
+    g_return_val_if_fail (outbuf_len > 0, FALSE);
+    g_return_val_if_fail (out_decap_len != NULL, FALSE);
+    g_return_val_if_fail (out_used != NULL, FALSE);
+    g_return_val_if_fail (out_need_more != NULL, FALSE);
+
+    *out_decap_len = 0;
+    *out_used = 0;
+    *out_need_more = FALSE;
+
+    if (inbuf_len < 4) {
+        *out_need_more = TRUE;
+        return TRUE;
+    }
+
+    /* Find the async control character */
+    for (i = 0; i < inbuf_len; i++) {
+        if (inbuf[i] == DIAG_CONTROL_CHAR) {
+            /* If the control character shows up in a position before a valid
+             * QCDM packet length (4), the packet is malformed.
+             */
+            if (i < 3) {
+                /* Tell the caller to advance the buffer past the control char */
+                *out_used = i + 1;
+                return FALSE;
+            }
+
+            pkt_len = i;
+            break;
+        }
+    }
+
+    /* No control char yet, need more data */
+    if (!pkt_len) {
+        *out_need_more = TRUE;
+        return TRUE;
+    }
+
+    /* Unescape first; note that pkt_len */
+    unesc_len = dm_unescape (inbuf, pkt_len, outbuf, outbuf_len, &escaping);
+    if (!unesc_len) {
+        /* Tell the caller to advance the buffer past the control char */
+        *out_used = pkt_len + 1;
+        return FALSE;
+    }
+
+    if (escaping) {
+        *out_need_more = TRUE;
+        return TRUE;
+    }
+
+    /* Check the CRC of the packet's data */
+    crc = crc16 (outbuf, unesc_len - 2);
+    pkt_crc = outbuf[unesc_len - 2] & 0xFF;
+    pkt_crc |= (outbuf[unesc_len - 1] & 0xFF) << 8;
+    if (crc != pkt_crc) {
+        *out_used = pkt_len + 1; /* packet + CRC + 0x7E */
+        return FALSE;
+    }
+
+    *out_used = pkt_len + 1; /* packet + CRC + 0x7E */
+    *out_decap_len = unesc_len - 2; /* decap_len should not include the CRC */
+    return TRUE;
+}
+
diff --git a/libqcdm/src/utils.h b/libqcdm/src/utils.h
new file mode 100644
index 0000000..5fccf7f
--- /dev/null
+++ b/libqcdm/src/utils.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <glib.h>
+
+#define DIAG_CONTROL_CHAR 0x7E
+#define DIAG_TRAILER_LEN  3
+
+guint16 crc16 (const char *buffer, gsize len);
+
+gsize dm_escape (const char *inbuf,
+                 gsize inbuf_len,
+                 char *outbuf,
+                 gsize outbuf_len);
+
+gsize dm_unescape (const char *inbuf,
+                   gsize inbuf_len,
+                   char *outbuf,
+                   gsize outbuf_len,
+                   gboolean *escaping);
+
+gsize dm_encapsulate_buffer (char *inbuf,
+                             gsize cmd_len,
+                             gsize inbuf_len,
+                             char *outbuf,
+                             gsize outbuf_len);
+
+gboolean dm_decapsulate_buffer (const char *inbuf,
+                                gsize inbuf_len,
+                                char *outbuf,
+                                gsize outbuf_len,
+                                gsize *out_decap_len,
+                                gsize *out_used,
+                                gboolean *out_need_more);
+
+#endif  /* UTILS_H */
+