libqmi-glib,qmi-codegen: add endian-ness annotation capability

Some values are sent by the firmware in big endian byte order,
specifically IP addresses, which are sent in network byte order
(ie, big endian).  Add the ability to specify the byte order
the firmware handles the value as, and convert that to host
byte order when reading/writing QMI buffers.

7 files changed, 306 insertions, 124 deletions

diff --git a/build-aux/qmi-codegen/FieldResult.py b/build-aux/qmi-codegen/FieldResult.py
index c249492..cc298ee 100644
--- a/build-aux/qmi-codegen/FieldResult.py
+++ b/build-aux/qmi-codegen/FieldResult.py
@@ -138,10 +138,12 @@ class FieldResult(Field):
             '        qmi_utils_read_guint16_from_buffer (\n'
             '            &buffer,\n'
             '            &buffer_len,\n'
+            '            QMI_ENDIAN_LITTLE,\n'
             '            &error_status);\n'
             '        qmi_utils_read_guint16_from_buffer (\n'
             '            &buffer,\n'
             '            &buffer_len,\n'
+            '            QMI_ENDIAN_LITTLE,\n'
             '            &error_code);\n'
             '\n'
             '        g_warn_if_fail (buffer_len == 0);\n'
diff --git a/build-aux/qmi-codegen/Variable.py b/build-aux/qmi-codegen/Variable.py
index 6eb65d6..3f3fcec 100644
--- a/build-aux/qmi-codegen/Variable.py
+++ b/build-aux/qmi-codegen/Variable.py
@@ -44,6 +44,15 @@ class Variable:
         """
         self.needs_dispose = False
 
+        self.endian = "QMI_ENDIAN_LITTLE"
+        if dictionary.has_key('endian'):
+            endian = dictionary['endian']
+            if endian == 'network' or endian == 'big':
+                self.endian = "QMI_ENDIAN_BIG"
+            elif endian == 'little':
+                pass
+            else:
+                raise ValueError("Invalid endian value %s" % endian)
 
     """
     Emits the code to declare specific new types required by the variable.
diff --git a/build-aux/qmi-codegen/VariableInteger.py b/build-aux/qmi-codegen/VariableInteger.py
index 0bb2a2c..68692a0 100644
--- a/build-aux/qmi-codegen/VariableInteger.py
+++ b/build-aux/qmi-codegen/VariableInteger.py
@@ -48,7 +48,6 @@ class VariableInteger(Variable):
             self.private_format = self.format
             self.public_format = dictionary['public-format'] if 'public-format' in dictionary else self.private_format
 
-
     """
     Read a single integer from the raw byte buffer
     """
@@ -59,7 +58,8 @@ class VariableInteger(Variable):
                          'len'            : self.guint_sized_size,
                          'variable_name'  : variable_name,
                          'buffer_name'    : buffer_name,
-                         'buffer_len'     : buffer_len }
+                         'buffer_len'     : buffer_len,
+                         'endian'         : self.endian }
 
         if self.format == 'guint-sized':
             template = (
@@ -68,6 +68,7 @@ class VariableInteger(Variable):
                 '${lp}    &${buffer_name},\n'
                 '${lp}    &${buffer_len},\n'
                 '${lp}    ${len},\n'
+                '${lp}    ${endian},\n'
                 '${lp}    &(${variable_name}));\n')
         elif self.private_format == self.public_format:
             template = (
@@ -75,6 +76,7 @@ class VariableInteger(Variable):
                 '${lp}qmi_utils_read_${private_format}_from_buffer (\n'
                 '${lp}    &${buffer_name},\n'
                 '${lp}    &${buffer_len},\n'
+                '${lp}    ${endian},\n'
                 '${lp}    &(${variable_name}));\n')
         else:
             template = (
@@ -85,6 +87,7 @@ class VariableInteger(Variable):
                 '${lp}    qmi_utils_read_${private_format}_from_buffer (\n'
                 '${lp}        &${buffer_name},\n'
                 '${lp}        &${buffer_len},\n'
+                '${lp}        ${endian},\n'
                 '${lp}        &tmp);\n'
                 '${lp}    ${variable_name} = (${public_format})tmp;\n'
                 '${lp}}\n')
@@ -100,7 +103,8 @@ class VariableInteger(Variable):
                          'len'            : self.guint_sized_size,
                          'variable_name'  : variable_name,
                          'buffer_name'    : buffer_name,
-                         'buffer_len'     : buffer_len }
+                         'buffer_len'     : buffer_len,
+                         'endian'         : self.endian }
 
         if self.format == 'guint-sized':
             template = (
@@ -109,6 +113,7 @@ class VariableInteger(Variable):
                 '${lp}    &${buffer_name},\n'
                 '${lp}    &${buffer_len},\n'
                 '${lp}    ${len},\n'
+                '${lp}    ${endian},\n'
                 '${lp}    &(${variable_name}));\n')
         elif self.private_format == self.public_format:
             template = (
@@ -116,6 +121,7 @@ class VariableInteger(Variable):
                 '${lp}qmi_utils_write_${private_format}_to_buffer (\n'
                 '${lp}    &${buffer_name},\n'
                 '${lp}    &${buffer_len},\n'
+                '${lp}    ${endian},\n'
                 '${lp}    &(${variable_name}));\n')
         else:
             template = (
@@ -127,6 +133,7 @@ class VariableInteger(Variable):
                 '${lp}    qmi_utils_write_${private_format}_to_buffer (\n'
                 '${lp}        &${buffer_name},\n'
                 '${lp}        &${buffer_len},\n'
+                '${lp}        ${endian},\n'
                 '${lp}        &tmp);\n'
                 '${lp}}\n')
         f.write(string.Template(template).substitute(translations))
@@ -164,7 +171,8 @@ class VariableInteger(Variable):
                          'buffer_name'    : buffer_name,
                          'buffer_len'     : buffer_len,
                          'common_format'  : common_format,
-                         'common_cast'    : common_cast }
+                         'common_cast'    : common_cast,
+                         'endian'         : self.endian }
 
         if self.format == 'guint-sized':
             template = (
@@ -177,6 +185,7 @@ class VariableInteger(Variable):
                 '${lp}        &${buffer_name},\n'
                 '${lp}        &${buffer_len},\n'
                 '${lp}        ${len},\n'
+                '${lp}        ${endian},\n'
                 '${lp}        &tmp);\n'
                 '\n'
                 '${lp}    g_string_append_printf (${printable}, "${common_format}", ${common_cast}tmp);\n'
@@ -191,6 +200,7 @@ class VariableInteger(Variable):
                 '${lp}    qmi_utils_read_${private_format}_from_buffer (\n'
                 '${lp}        &${buffer_name},\n'
                 '${lp}        &${buffer_len},\n'
+                '${lp}        ${endian},\n'
                 '${lp}        &tmp);\n'
                 '\n'
                 '${lp}    g_string_append_printf (${printable}, "${common_format}", ${common_cast}tmp);\n'
diff --git a/docs/reference/libqmi-glib/libqmi-glib-common.sections b/docs/reference/libqmi-glib/libqmi-glib-common.sections
index cb331e7..097cd34 100644
--- a/docs/reference/libqmi-glib/libqmi-glib-common.sections
+++ b/docs/reference/libqmi-glib/libqmi-glib-common.sections
@@ -641,6 +641,7 @@ qmi_message_get_tlv_printable
 
 <SECTION>
 <FILE>qmi-utils</FILE>
+QmiEndian
 <SUBSECTION Traces>
 qmi_utils_get_traces_enabled
 qmi_utils_set_traces_enabled
diff --git a/libqmi-glib/qmi-utils.c b/libqmi-glib/qmi-utils.c
index 3e5101b..2b7d8fc 100644
--- a/libqmi-glib/qmi-utils.c
+++ b/libqmi-glib/qmi-utils.c
@@ -19,6 +19,7 @@
  * Boston, MA 02110-1301 USA.
  *
  * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ * Copyright (C) 2012 Dan Williams <dcbw@redhat.com>
  */
 
 #include <config.h>
@@ -101,6 +102,7 @@ print_read_bytes_trace (const gchar *type,
  * qmi_utils_read_guint8_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: ignored
  * @out: return location for the read variable.
  *
  * Reads an unsigned byte from the buffer.
@@ -114,6 +116,7 @@ print_read_bytes_trace (const gchar *type,
 void
 qmi_utils_read_guint8_from_buffer (const guint8 **buffer,
                                    guint16       *buffer_size,
+                                   QmiEndian      endian,
                                    guint8        *out)
 {
     g_assert (out != NULL);
@@ -133,6 +136,7 @@ qmi_utils_read_guint8_from_buffer (const guint8 **buffer,
  * qmi_utils_read_gint8_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: ignored
  * @out: return location for the read variable.
  *
  * Reads a signed byte from the buffer.
@@ -146,6 +150,7 @@ qmi_utils_read_guint8_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_gint8_from_buffer (const guint8 **buffer,
                                   guint16       *buffer_size,
+                                  QmiEndian      endian,
                                   gint8         *out)
 {
     g_assert (out != NULL);
@@ -165,11 +170,12 @@ qmi_utils_read_gint8_from_buffer (const guint8 **buffer,
  * qmi_utils_read_guint16_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads an unsigned 16-bit integer from the buffer. The number in the buffer is
- * expected to be given in Little-Endian, and this method takes care of
- * converting the read value to the proper host endianness.
+ * expected to be given in the byte order specificed by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
  *
  * The user needs to make sure that at least 2 bytes are available
  * in the buffer.
@@ -180,6 +186,7 @@ qmi_utils_read_gint8_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
                                     guint16       *buffer_size,
+                                    QmiEndian      endian,
                                     guint16       *out)
 {
     g_assert (out != NULL);
@@ -188,7 +195,10 @@ qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
     g_assert (*buffer_size >= 2);
 
     memcpy (out, &((*buffer)[0]), 2);
-    *out = GUINT16_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT16_FROM_BE (*out);
+    else
+        *out = GUINT16_FROM_LE (*out);
 
     print_read_bytes_trace ("guint16", &(*buffer)[0], out, 2);
 
@@ -200,11 +210,12 @@ qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
  * qmi_utils_read_gint16_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads a signed 16-bit integer from the buffer. The number in the buffer is
- * expected to be given in Little-Endian, and this method takes care of
- * converting the read value to the proper host endianness.
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
  *
  * The user needs to make sure that at least 2 bytes are available
  * in the buffer.
@@ -215,6 +226,7 @@ qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_gint16_from_buffer (const guint8 **buffer,
                                    guint16       *buffer_size,
+                                   QmiEndian      endian,
                                    gint16        *out)
 {
     g_assert (out != NULL);
@@ -223,7 +235,10 @@ qmi_utils_read_gint16_from_buffer (const guint8 **buffer,
     g_assert (*buffer_size >= 2);
 
     memcpy (out, &((*buffer)[0]), 2);
-    *out = GINT16_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GINT16_FROM_BE (*out);
+    else
+        *out = GINT16_FROM_LE (*out);
 
     print_read_bytes_trace ("gint16", &(*buffer)[0], out, 2);
 
@@ -235,11 +250,12 @@ qmi_utils_read_gint16_from_buffer (const guint8 **buffer,
  * qmi_utils_read_guint32_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads an unsigned 32-bit integer from the buffer. The number in the buffer is
- * expected to be given in Little-Endian, and this method takes care of
- * converting the read value to the proper host endianness.
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
  *
  * The user needs to make sure that at least 4 bytes are available
  * in the buffer.
@@ -250,6 +266,7 @@ qmi_utils_read_gint16_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
                                     guint16       *buffer_size,
+                                    QmiEndian      endian,
                                     guint32       *out)
 {
     g_assert (out != NULL);
@@ -258,7 +275,10 @@ qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
     g_assert (*buffer_size >= 4);
 
     memcpy (out, &((*buffer)[0]), 4);
-    *out = GUINT32_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT32_FROM_BE (*out);
+    else
+        *out = GUINT32_FROM_LE (*out);
 
     print_read_bytes_trace ("guint32", &(*buffer)[0], out, 4);
 
@@ -270,11 +290,12 @@ qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
  * qmi_utils_read_gint32_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads a signed 32-bit integer from the buffer. The number in the buffer is
- * expected to be given in Little-Endian, and this method takes care of
- * converting the read value to the proper host endianness.
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
  *
  * The user needs to make sure that at least 4 bytes are available
  * in the buffer.
@@ -285,6 +306,7 @@ qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_gint32_from_buffer (const guint8 **buffer,
                                    guint16       *buffer_size,
+                                   QmiEndian      endian,
                                    gint32        *out)
 {
     g_assert (out != NULL);
@@ -293,7 +315,10 @@ qmi_utils_read_gint32_from_buffer (const guint8 **buffer,
     g_assert (*buffer_size >= 4);
 
     memcpy (out, &((*buffer)[0]), 4);
-    *out = GINT32_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GINT32_FROM_BE (*out);
+    else
+        *out = GINT32_FROM_LE (*out);
 
     print_read_bytes_trace ("gint32", &(*buffer)[0], out, 4);
 
@@ -305,11 +330,12 @@ qmi_utils_read_gint32_from_buffer (const guint8 **buffer,
  * qmi_utils_read_guint64_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads an unsigned 64-bit integer from the buffer. The number in the buffer is
- * expected to be given in Little-Endian, and this method takes care of
- * converting the read value to the proper host endianness.
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
  *
  * The user needs to make sure that at least 8 bytes are available
  * in the buffer.
@@ -320,6 +346,7 @@ qmi_utils_read_gint32_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
                                     guint16       *buffer_size,
+                                    QmiEndian      endian,
                                     guint64       *out)
 {
     g_assert (out != NULL);
@@ -328,7 +355,10 @@ qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
     g_assert (*buffer_size >= 8);
 
     memcpy (out, &((*buffer)[0]), 8);
-    *out = GUINT64_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT64_FROM_BE (*out);
+    else
+        *out = GUINT64_FROM_LE (*out);
 
     print_read_bytes_trace ("guint64", &(*buffer)[0], out, 8);
 
@@ -340,11 +370,12 @@ qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
  * qmi_utils_read_gint64_from_buffer:
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads a signed 64-bit integer from the buffer. The number in the buffer is
- * expected to be given in Little-Endian, and this method takes care of
- * converting the read value to the proper host endianness.
+ * expected to be given in the byte order specified by @endian, and this method
+ * takes care of converting the read value to the proper host endianness.
  *
  * The user needs to make sure that at least 8 bytes are available
  * in the buffer.
@@ -355,6 +386,7 @@ qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
 void
 qmi_utils_read_gint64_from_buffer (const guint8 **buffer,
                                    guint16       *buffer_size,
+                                   QmiEndian      endian,
                                    gint64        *out)
 {
     g_assert (out != NULL);
@@ -363,7 +395,10 @@ qmi_utils_read_gint64_from_buffer (const guint8 **buffer,
     g_assert (*buffer_size >= 8);
 
     memcpy (out, &((*buffer)[0]), 8);
-    *out = GINT64_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GINT64_FROM_BE (*out);
+    else
+        *out = GINT64_FROM_LE (*out);
 
     print_read_bytes_trace ("gint64", &(*buffer)[0], out, 8);
 
@@ -376,11 +411,13 @@ qmi_utils_read_gint64_from_buffer (const guint8 **buffer,
  * @buffer: a buffer with raw binary data.
  * @buffer_size: size of @buffer.
  * @n_bytes: number of bytes to read.
+ * @endian: endianness of firmware value; swapped to host byte order if necessary
  * @out: return location for the read variable.
  *
  * Reads a @n_bytes-sized unsigned integer from the buffer. The number in the
- * buffer is expected to be given in Little-Endian, and this method takes care
- * of converting the read value to the proper host endianness.
+ * buffer is expected to be given in the byte order specified by @endian, and
+ * this method takes care of converting the read value to the proper host
+ * endianness.
  *
  * The user needs to make sure that at least @n_bytes bytes are available
  * in the buffer.
@@ -392,6 +429,7 @@ void
 qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
                                         guint16       *buffer_size,
                                         guint          n_bytes,
+                                        QmiEndian      endian,
                                         guint64       *out)
 {
     g_assert (out != NULL);
@@ -401,7 +439,10 @@ qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
 
     *out = 0;
     memcpy (out, *buffer, n_bytes);
-    *out = GUINT64_FROM_LE (*out);
+    if (endian == QMI_ENDIAN_BIG)
+        *out = GUINT64_FROM_BE (*out);
+    else
+        *out = GUINT64_FROM_LE (*out);
 
     *buffer = &((*buffer)[n_bytes]);
     *buffer_size = (*buffer_size) - n_bytes;
@@ -411,6 +452,7 @@ qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
  * qmi_utils_write_guint8_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: ignored
  * @in: location of the variable to be written.
  *
  * Writes an unsigned byte into the buffer.
@@ -423,6 +465,7 @@ qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
 void
 qmi_utils_write_guint8_to_buffer (guint8  **buffer,
                                   guint16  *buffer_size,
+                                  QmiEndian endian,
                                   guint8   *in)
 {
     g_assert (in != NULL);
@@ -440,6 +483,7 @@ qmi_utils_write_guint8_to_buffer (guint8  **buffer,
  * qmi_utils_write_gint8_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: ignored
  * @in: location of the variable to be written.
  *
  * Writes a signed byte into the buffer.
@@ -452,6 +496,7 @@ qmi_utils_write_guint8_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_gint8_to_buffer (guint8  **buffer,
                                  guint16  *buffer_size,
+                                 QmiEndian endian,
                                  gint8    *in)
 {
     g_assert (in != NULL);
@@ -469,11 +514,12 @@ qmi_utils_write_gint8_to_buffer (guint8  **buffer,
  * qmi_utils_write_guint16_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes an unsigned 16-bit integer into the buffer. The number to be written
  * is expected to be given in host endianness, and this method takes care of
- * converting the value written to Little-Endian.
+ * converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least 2 bytes long.
  *
@@ -483,6 +529,7 @@ qmi_utils_write_gint8_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_guint16_to_buffer (guint8  **buffer,
                                    guint16  *buffer_size,
+                                   QmiEndian endian,
                                    guint16  *in)
 {
     guint16 tmp;
@@ -492,7 +539,10 @@ qmi_utils_write_guint16_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= 2);
 
-    tmp = GUINT16_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT16_TO_BE (*in);
+    else
+        tmp = GUINT16_TO_LE (*in);
     memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
 
     *buffer = &((*buffer)[2]);
@@ -503,11 +553,12 @@ qmi_utils_write_guint16_to_buffer (guint8  **buffer,
  * qmi_utils_write_gint16_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes a signed 16-bit integer into the buffer. The number to be written
  * is expected to be given in host endianness, and this method takes care of
- * converting the value written to Little-Endian.
+ * converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least 2 bytes long.
  *
@@ -517,6 +568,7 @@ qmi_utils_write_guint16_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_gint16_to_buffer (guint8  **buffer,
                                   guint16  *buffer_size,
+                                  QmiEndian endian,
                                   gint16   *in)
 {
     gint16 tmp;
@@ -526,7 +578,10 @@ qmi_utils_write_gint16_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= 2);
 
-    tmp = GINT16_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GINT16_TO_BE (*in);
+    else
+        tmp = GINT16_TO_LE (*in);
     memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
 
     *buffer = &((*buffer)[2]);
@@ -537,11 +592,12 @@ qmi_utils_write_gint16_to_buffer (guint8  **buffer,
  * qmi_utils_write_guint32_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes an unsigned 32-bit integer into the buffer. The number to be written
  * is expected to be given in host endianness, and this method takes care of
- * converting the value written to Little-Endian.
+ * converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least 4 bytes long.
  *
@@ -551,6 +607,7 @@ qmi_utils_write_gint16_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_guint32_to_buffer (guint8  **buffer,
                                    guint16  *buffer_size,
+                                   QmiEndian endian,
                                    guint32  *in)
 {
     guint32 tmp;
@@ -560,7 +617,10 @@ qmi_utils_write_guint32_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= 4);
 
-    tmp = GUINT32_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT32_TO_BE (*in);
+    else
+        tmp = GUINT32_TO_LE (*in);
     memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
 
     *buffer = &((*buffer)[4]);
@@ -571,11 +631,12 @@ qmi_utils_write_guint32_to_buffer (guint8  **buffer,
  * qmi_utils_write_gint32_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes a signed 32-bit integer into the buffer. The number to be written
  * is expected to be given in host endianness, and this method takes care of
- * converting the value written to Little-Endian.
+ * converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least 4 bytes long.
  *
@@ -585,6 +646,7 @@ qmi_utils_write_guint32_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_gint32_to_buffer (guint8  **buffer,
                                   guint16  *buffer_size,
+                                  QmiEndian endian,
                                   gint32   *in)
 {
     gint32 tmp;
@@ -594,7 +656,10 @@ qmi_utils_write_gint32_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= 4);
 
-    tmp = GINT32_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GINT32_TO_BE (*in);
+    else
+        tmp = GINT32_TO_LE (*in);
     memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
 
     *buffer = &((*buffer)[4]);
@@ -605,11 +670,12 @@ qmi_utils_write_gint32_to_buffer (guint8  **buffer,
  * qmi_utils_write_guint64_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes an unsigned 64-bit integer into the buffer. The number to be written
  * is expected to be given in host endianness, and this method takes care of
- * converting the value written to Little-Endian.
+ * converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least 8 bytes long.
  *
@@ -619,6 +685,7 @@ qmi_utils_write_gint32_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_guint64_to_buffer (guint8  **buffer,
                                    guint16  *buffer_size,
+                                   QmiEndian endian,
                                    guint64  *in)
 {
     guint64 tmp;
@@ -628,7 +695,10 @@ qmi_utils_write_guint64_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= 8);
 
-    tmp = GUINT64_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT64_TO_BE (*in);
+    else
+        tmp = GUINT64_TO_LE (*in);
     memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
 
     *buffer = &((*buffer)[8]);
@@ -639,11 +709,12 @@ qmi_utils_write_guint64_to_buffer (guint8  **buffer,
  * qmi_utils_write_gint64_to_buffer:
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes a signed 64-bit integer into the buffer. The number to be written
  * is expected to be given in host endianness, and this method takes care of
- * converting the value written to Little-Endian.
+ * converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least 8 bytes long.
  *
@@ -653,6 +724,7 @@ qmi_utils_write_guint64_to_buffer (guint8  **buffer,
 void
 qmi_utils_write_gint64_to_buffer (guint8  **buffer,
                                   guint16  *buffer_size,
+                                  QmiEndian endian,
                                   gint64   *in)
 {
     gint64 tmp;
@@ -662,7 +734,10 @@ qmi_utils_write_gint64_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= 8);
 
-    tmp = GINT64_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GINT64_TO_BE (*in);
+    else
+        tmp = GINT64_TO_LE (*in);
     memcpy (&(*buffer)[0], &tmp, sizeof (tmp));
 
     *buffer = &((*buffer)[8]);
@@ -674,11 +749,12 @@ qmi_utils_write_gint64_to_buffer (guint8  **buffer,
  * @buffer: a buffer.
  * @buffer_size: size of @buffer.
  * @n_bytes: number of bytes to read.
+ * @endian: endianness of firmware value; swapped from host byte order if necessary
  * @in: location of the variable to be written.
  *
  * Writes a @n_bytes-sized unsigned integer into the buffer. The number to be
  * written is expected to be given in host endianness, and this method takes
- * care of converting the value written to Little-Endian.
+ * care of converting the value written to the byte order specified by @endian.
  *
  * The user needs to make sure that the buffer is at least @n_bytes bytes long.
  *
@@ -689,6 +765,7 @@ void
 qmi_utils_write_sized_guint_to_buffer (guint8  **buffer,
                                        guint16  *buffer_size,
                                        guint     n_bytes,
+                                       QmiEndian endian,
                                        guint64  *in)
 {
     guint64 tmp;
@@ -698,7 +775,10 @@ qmi_utils_write_sized_guint_to_buffer (guint8  **buffer,
     g_assert (buffer_size != NULL);
     g_assert (*buffer_size >= n_bytes);
 
-    tmp = GUINT64_TO_LE (*in);
+    if (endian == QMI_ENDIAN_BIG)
+        tmp = GUINT64_TO_BE (*in);
+    else
+        tmp = GUINT64_TO_LE (*in);
     memcpy (*buffer, &tmp, n_bytes);
 
     *buffer = &((*buffer)[n_bytes]);
@@ -745,11 +825,17 @@ qmi_utils_read_string_from_buffer (const guint8 **buffer,
         string_length = *buffer_size;
         break;
     case 8:
-        qmi_utils_read_guint8_from_buffer (buffer, buffer_size, &string_length_8);
+        qmi_utils_read_guint8_from_buffer (buffer,
+                                           buffer_size,
+                                           QMI_ENDIAN_LITTLE,
+                                           &string_length_8);
         string_length = string_length_8;
         break;
     case 16:
-        qmi_utils_read_guint16_from_buffer (buffer, buffer_size, &string_length_16);
+        qmi_utils_read_guint16_from_buffer (buffer,
+                                            buffer_size,
+                                            QMI_ENDIAN_LITTLE,
+                                            &string_length_16);
         string_length = string_length_16;
         break;
     default:
@@ -842,12 +928,18 @@ qmi_utils_write_string_to_buffer (guint8      **buffer,
     case 8:
         g_warn_if_fail (len <= G_MAXUINT8);
         len_8 = (guint8)len;
-        qmi_utils_write_guint8_to_buffer (buffer, buffer_size, &len_8);
+        qmi_utils_write_guint8_to_buffer (buffer,
+                                          buffer_size,
+                                          QMI_ENDIAN_LITTLE,
+                                          &len_8);
         break;
     case 16:
         g_warn_if_fail (len <= G_MAXUINT16);
         len_16 = (guint16)len;
-        qmi_utils_write_guint16_to_buffer (buffer, buffer_size, &len_16);
+        qmi_utils_write_guint16_to_buffer (buffer,
+                                           buffer_size,
+                                           QMI_ENDIAN_LITTLE,
+                                           &len_16);
         break;
     default:
         g_assert_not_reached ();
diff --git a/libqmi-glib/qmi-utils.h b/libqmi-glib/qmi-utils.h
index c67d332..d2e79d0 100644
--- a/libqmi-glib/qmi-utils.h
+++ b/libqmi-glib/qmi-utils.h
@@ -19,6 +19,7 @@
  * Boston, MA 02110-1301 USA.
  *
  * Copyright (C) 2012 Aleksander Morgado <aleksander@lanedo.com>
+ * Copyright (C) 2012 Dan Williams <dcbw@redhat.com>
  */
 
 #ifndef _LIBQMI_GLIB_QMI_UTILS_H_
@@ -32,72 +33,102 @@
 
 G_BEGIN_DECLS
 
+/**
+ * QmiEndian:
+ * @QMI_ENDIAN_LITTLE: Little endian.
+ * @QMI_ENDIAN_BIG: Big endian.
+ *
+ * Type of endianness
+ */
+typedef enum {
+    QMI_ENDIAN_LITTLE = 0,
+    QMI_ENDIAN_BIG    = 1
+} QmiEndian;
+
 /* Reading/Writing integer variables */
 
 void qmi_utils_read_guint8_from_buffer  (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          guint8        *out);
 void qmi_utils_read_gint8_from_buffer   (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          gint8         *out);
 
 void qmi_utils_read_guint16_from_buffer (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          guint16       *out);
 void qmi_utils_read_gint16_from_buffer  (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          gint16        *out);
 
 void qmi_utils_read_guint32_from_buffer (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          guint32       *out);
 void qmi_utils_read_gint32_from_buffer  (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          gint32        *out);
 
 void qmi_utils_read_guint64_from_buffer (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          guint64       *out);
 void qmi_utils_read_gint64_from_buffer  (const guint8 **buffer,
                                          guint16       *buffer_size,
+                                         QmiEndian      endian,
                                          gint64        *out);
 
 void qmi_utils_read_sized_guint_from_buffer (const guint8 **buffer,
                                              guint16       *buffer_size,
                                              guint          n_bytes,
+                                             QmiEndian      endian,
                                              guint64       *out);
 
 void qmi_utils_write_guint8_to_buffer (guint8  **buffer,
                                        guint16  *buffer_size,
+                                       QmiEndian endian,
                                        guint8   *in);
 void qmi_utils_write_gint8_to_buffer  (guint8  **buffer,
                                        guint16  *buffer_size,
+                                       QmiEndian endian,
                                        gint8    *in);
 
 void qmi_utils_write_guint16_to_buffer (guint8  **buffer,
                                         guint16  *buffer_size,
+                                        QmiEndian endian,
                                         guint16  *in);
 void qmi_utils_write_gint16_to_buffer  (guint8  **buffer,
                                         guint16  *buffer_size,
+                                        QmiEndian endian,
                                         gint16   *in);
 
 void qmi_utils_write_guint32_to_buffer (guint8  **buffer,
                                         guint16  *buffer_size,
+                                        QmiEndian endian,
                                         guint32  *in);
 void qmi_utils_write_gint32_to_buffer  (guint8  **buffer,
                                         guint16  *buffer_size,
+                                        QmiEndian endian,
                                         gint32   *in);
 
 void qmi_utils_write_guint64_to_buffer (guint8  **buffer,
                                         guint16  *buffer_size,
+                                        QmiEndian endian,
                                         guint64  *in);
 void qmi_utils_write_gint64_to_buffer  (guint8  **buffer,
                                         guint16  *buffer_size,
+                                        QmiEndian endian,
                                         gint64   *in);
 
 void qmi_utils_write_sized_guint_to_buffer (guint8  **buffer,
                                             guint16  *buffer_size,
                                             guint     n_bytes,
+                                            QmiEndian endian,
                                             guint64  *in);
 
 /* Reading/Writing string variables */
diff --git a/libqmi-glib/test/test-utils.c b/libqmi-glib/test/test-utils.c
index 0e91cc8..37b9a74 100644
--- a/libqmi-glib/test/test-utils.c
+++ b/libqmi-glib/test/test-utils.c
@@ -17,6 +17,14 @@
 #include <string.h>
 #include "qmi-utils.h"
 
+#define VAL_EQUAL(t, v, c, e) \
+{ \
+    if (e == QMI_ENDIAN_LITTLE) \
+        g_assert_cmpint (c##_FROM_LE (t), ==, v); \
+    else \
+        g_assert_cmpint (c##_FROM_BE (t), ==, v); \
+}
+
 static void
 test_utils_uint8 (void)
 {
@@ -38,8 +46,8 @@ test_utils_uint8 (void)
     while (in_buffer_size) {
         guint8 tmp;
 
-        qmi_utils_read_guint8_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
-        qmi_utils_write_guint8_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_read_guint8_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        qmi_utils_write_guint8_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -67,8 +75,8 @@ test_utils_int8 (void)
     while (in_buffer_size) {
         gint8 tmp;
 
-        qmi_utils_read_gint8_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
-        qmi_utils_write_gint8_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_read_gint8_from_buffer (&in_buffer_walker, &in_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
+        qmi_utils_write_gint8_to_buffer (&out_buffer_walker, &out_buffer_size, QMI_ENDIAN_LITTLE, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -76,7 +84,7 @@ test_utils_int8 (void)
 }
 
 static void
-test_utils_uint16 (void)
+test_utils_uint16 (gconstpointer user_data)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -85,6 +93,7 @@ test_utils_uint16 (void)
         0x500F, 0xE2EB, 0x00B6, 0x0000
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -101,11 +110,11 @@ test_utils_uint16 (void)
     while (in_buffer_size) {
         guint16 tmp;
 
-        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GUINT16, endian);
 
-        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -113,7 +122,7 @@ test_utils_uint16 (void)
 }
 
 static void
-test_utils_int16 (void)
+test_utils_int16 (gconstpointer user_data)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -122,6 +131,7 @@ test_utils_int16 (void)
         0x500F, 0xE2EB, 0x00B6, 0x0000
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -138,11 +148,11 @@ test_utils_int16 (void)
     while (in_buffer_size) {
         gint16 tmp;
 
-        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GINT16, endian);
 
-        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -150,7 +160,7 @@ test_utils_int16 (void)
 }
 
 static void
-test_utils_uint16_unaligned (void)
+test_utils_uint16_unaligned (gconstpointer user_data)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -159,6 +169,7 @@ test_utils_uint16_unaligned (void)
         0x500F, 0xE2EB, 0x00B6, 0x0000
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -175,11 +186,11 @@ test_utils_uint16_unaligned (void)
     while (in_buffer_size) {
         guint16 tmp;
 
-        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_guint16_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GUINT16, endian);
 
-        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_guint16_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -187,7 +198,7 @@ test_utils_uint16_unaligned (void)
 }
 
 static void
-test_utils_int16_unaligned (void)
+test_utils_int16_unaligned (gconstpointer user_data)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -196,6 +207,7 @@ test_utils_int16_unaligned (void)
         0x500F, 0xE2EB, 0x00B6, 0x0000
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -212,11 +224,11 @@ test_utils_int16_unaligned (void)
     while (in_buffer_size) {
         gint16 tmp;
 
-        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_gint16_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GINT16, endian);
 
-        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_gint16_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -224,7 +236,7 @@ test_utils_int16_unaligned (void)
 }
 
 static void
-test_utils_uint32 (void)
+test_utils_uint32 (gconstpointer user_data)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -233,6 +245,7 @@ test_utils_uint32 (void)
         0xE2EB500F, 0x000000B6
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -249,11 +262,11 @@ test_utils_uint32 (void)
     while (in_buffer_size) {
         guint32 tmp;
 
-        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GUINT32, endian);
 
-        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -261,7 +274,7 @@ test_utils_uint32 (void)
 }
 
 static void
-test_utils_int32 (void)
+test_utils_int32 (gconstpointer user_data)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -270,6 +283,7 @@ test_utils_int32 (void)
         0xE2EB500F, 0x000000B6
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -286,11 +300,11 @@ test_utils_int32 (void)
     while (in_buffer_size) {
         gint32 tmp;
 
-        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GINT32, endian);
 
-        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -298,7 +312,7 @@ test_utils_int32 (void)
 }
 
 static void
-test_utils_uint32_unaligned (void)
+test_utils_uint32_unaligned (gconstpointer user_data)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -307,6 +321,7 @@ test_utils_uint32_unaligned (void)
         0xE2EB500F, 0x000000B6
     };
     guint8 out_buffer[8] = { 0 };
+    QmiEndian endian = (QmiEndian) user_data;
 
     guint i;
     guint16 in_buffer_size;
@@ -323,11 +338,11 @@ test_utils_uint32_unaligned (void)
     while (in_buffer_size) {
         guint32 tmp;
 
-        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_guint32_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GUINT32, endian);
 
-        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_guint32_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -335,7 +350,7 @@ test_utils_uint32_unaligned (void)
 }
 
 static void
-test_utils_int32_unaligned (void)
+test_utils_int32_unaligned (gconstpointer user_data)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -350,6 +365,7 @@ test_utils_int32_unaligned (void)
     const guint8 *in_buffer_walker;
     guint16 out_buffer_size;
     guint8 *out_buffer_walker;
+    QmiEndian endian = (QmiEndian) user_data;
 
     in_buffer_size = sizeof (in_buffer) - 1;
     in_buffer_walker = &in_buffer[1];
@@ -360,11 +376,11 @@ test_utils_int32_unaligned (void)
     while (in_buffer_size) {
         gint32 tmp;
 
-        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_gint32_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GINT32, endian);
 
-        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_gint32_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -372,7 +388,7 @@ test_utils_int32_unaligned (void)
 }
 
 static void
-test_utils_uint64 (void)
+test_utils_uint64 (gconstpointer user_data)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -387,6 +403,7 @@ test_utils_uint64 (void)
     const guint8 *in_buffer_walker;
     guint16 out_buffer_size;
     guint8 *out_buffer_walker;
+    QmiEndian endian = (QmiEndian) user_data;
 
     in_buffer_size = sizeof (in_buffer);
     in_buffer_walker = &in_buffer[0];
@@ -397,11 +414,11 @@ test_utils_uint64 (void)
     while (in_buffer_size) {
         guint64 tmp;
 
-        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GUINT64, endian);
 
-        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -409,7 +426,7 @@ test_utils_uint64 (void)
 }
 
 static void
-test_utils_int64 (void)
+test_utils_int64 (gconstpointer user_data)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -424,6 +441,7 @@ test_utils_int64 (void)
     const guint8 *in_buffer_walker;
     guint16 out_buffer_size;
     guint8 *out_buffer_walker;
+    QmiEndian endian = (QmiEndian) user_data;
 
     in_buffer_size = sizeof (in_buffer);
     in_buffer_walker = &in_buffer[0];
@@ -434,11 +452,11 @@ test_utils_int64 (void)
     while (in_buffer_size) {
         gint64 tmp;
 
-        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GINT64, endian);
 
-        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -446,7 +464,7 @@ test_utils_int64 (void)
 }
 
 static void
-test_utils_uint64_unaligned (void)
+test_utils_uint64_unaligned (gconstpointer user_data)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -461,6 +479,7 @@ test_utils_uint64_unaligned (void)
     const guint8 *in_buffer_walker;
     guint16 out_buffer_size;
     guint8 *out_buffer_walker;
+    QmiEndian endian = (QmiEndian) user_data;
 
     in_buffer_size = sizeof (in_buffer) - 1;
     in_buffer_walker = &in_buffer[1];
@@ -471,11 +490,11 @@ test_utils_uint64_unaligned (void)
     while (in_buffer_size) {
         guint64 tmp;
 
-        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_guint64_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GUINT64, endian);
 
-        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_guint64_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -483,7 +502,7 @@ test_utils_uint64_unaligned (void)
 }
 
 static void
-test_utils_int64_unaligned (void)
+test_utils_int64_unaligned (gconstpointer user_data)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -498,6 +517,7 @@ test_utils_int64_unaligned (void)
     const guint8 *in_buffer_walker;
     guint16 out_buffer_size;
     guint8 *out_buffer_walker;
+    QmiEndian endian = (QmiEndian) user_data;
 
     in_buffer_size = sizeof (in_buffer) - 1;
     in_buffer_walker = &in_buffer[1];
@@ -508,11 +528,11 @@ test_utils_int64_unaligned (void)
     while (in_buffer_size) {
         gint64 tmp;
 
-        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, &tmp);
+        qmi_utils_read_gint64_from_buffer (&in_buffer_walker, &in_buffer_size, endian, &tmp);
 
-        g_assert (tmp == values[i++]);
+        VAL_EQUAL (tmp, values[i++], GINT64, endian);
 
-        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, &tmp);
+        qmi_utils_write_gint64_to_buffer (&out_buffer_walker, &out_buffer_size, endian, &tmp);
     }
 
     g_assert_cmpuint (out_buffer_size, ==, 0);
@@ -520,7 +540,7 @@ test_utils_int64_unaligned (void)
 }
 
 static void
-common_test_utils_uint_sized (guint n_bytes)
+common_test_utils_uint_sized (guint n_bytes, QmiEndian endian)
 {
     static const guint8 in_buffer[8] = {
         0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -553,26 +573,26 @@ common_test_utils_uint_sized (guint n_bytes)
     out_buffer_walker = &out_buffer[0];
     i = 0;
 
-    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, &tmp);
-    g_assert (tmp == value);
-    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, &tmp);
+    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, endian, &tmp);
+    VAL_EQUAL (tmp, value, GUINT64, endian);
+    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, endian, &tmp);
 
     g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
     g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
 }
 
 static void
-test_utils_uint_sized (void)
+test_utils_uint_sized (gconstpointer user_data)
 {
     guint i;
 
     for (i = 1; i <= 8; i++) {
-        common_test_utils_uint_sized (i);
+        common_test_utils_uint_sized (i, (QmiEndian) user_data);
     }
 }
 
 static void
-common_test_utils_uint_sized_unaligned (guint n_bytes)
+common_test_utils_uint_sized_unaligned (guint n_bytes, QmiEndian endian)
 {
     static const guint8 in_buffer[9] = {
         0x00, 0x0F, 0x50, 0xEB, 0xE2, 0xB6, 0x00, 0x00, 0x00
@@ -605,24 +625,27 @@ common_test_utils_uint_sized_unaligned (guint n_bytes)
     out_buffer_walker = &out_buffer[0];
     i = 0;
 
-    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, &tmp);
-    g_assert (tmp == value);
-    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, &tmp);
+    qmi_utils_read_sized_guint_from_buffer (&in_buffer_walker, &in_buffer_size, n_bytes, endian, &tmp);
+    VAL_EQUAL (tmp, value, GUINT64, endian);
+    qmi_utils_write_sized_guint_to_buffer (&out_buffer_walker, &out_buffer_size, n_bytes, endian, &tmp);
 
     g_assert_cmpuint (out_buffer_size, ==, 8 - n_bytes);
     g_assert (memcmp (expected_out_buffer, out_buffer, sizeof (expected_out_buffer)) == 0);
 }
 
 static void
-test_utils_uint_sized_unaligned (void)
+test_utils_uint_sized_unaligned (gconstpointer user_data)
 {
     guint i;
 
     for (i = 1; i <= 8; i++) {
-        common_test_utils_uint_sized_unaligned (i);
+        common_test_utils_uint_sized_unaligned (i, (QmiEndian) user_data);
     }
 }
 
+#define LE ((gconstpointer) QMI_ENDIAN_LITTLE)
+#define BE ((gconstpointer) QMI_ENDIAN_BIG)
+
 int main (int argc, char **argv)
 {
     g_type_init ();
@@ -631,23 +654,37 @@ int main (int argc, char **argv)
     g_test_add_func ("/libqmi-glib/utils/uint8",  test_utils_uint8);
     g_test_add_func ("/libqmi-glib/utils/int8",   test_utils_int8);
 
-    g_test_add_func ("/libqmi-glib/utils/uint16",           test_utils_uint16);
-    g_test_add_func ("/libqmi-glib/utils/int16",            test_utils_int16);
-    g_test_add_func ("/libqmi-glib/utils/uint16-unaligned", test_utils_uint16_unaligned);
-    g_test_add_func ("/libqmi-glib/utils/int16-unaligned",  test_utils_int16_unaligned);
-
-    g_test_add_func ("/libqmi-glib/utils/uint32",           test_utils_uint32);
-    g_test_add_func ("/libqmi-glib/utils/int32",            test_utils_int32);
-    g_test_add_func ("/libqmi-glib/utils/uint32/unaligned", test_utils_uint32_unaligned);
-    g_test_add_func ("/libqmi-glib/utils/int32/unaligned",  test_utils_int32_unaligned);
-
-    g_test_add_func ("/libqmi-glib/utils/uint64",           test_utils_uint64);
-    g_test_add_func ("/libqmi-glib/utils/int64",            test_utils_int64);
-    g_test_add_func ("/libqmi-glib/utils/uint64/unaligned", test_utils_uint64_unaligned);
-    g_test_add_func ("/libqmi-glib/utils/int64/unaligned",  test_utils_int64_unaligned);
-
-    g_test_add_func ("/libqmi-glib/utils/uint-sized",           test_utils_uint_sized);
-    g_test_add_func ("/libqmi-glib/utils/uint-sized/unaligned", test_utils_uint_sized_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/uint16-LE",           LE, test_utils_uint16);
+    g_test_add_data_func ("/libqmi-glib/utils/uint16-BE",           BE, test_utils_uint16);
+    g_test_add_data_func ("/libqmi-glib/utils/int16-LE",            LE, test_utils_int16);
+    g_test_add_data_func ("/libqmi-glib/utils/int16-BE",            BE, test_utils_int16);
+    g_test_add_data_func ("/libqmi-glib/utils/uint16-unaligned-LE", LE, test_utils_uint16_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/uint16-unaligned-Be", BE, test_utils_uint16_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/int16-unaligned-LE",  LE, test_utils_int16_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/int16-unaligned-BE",  BE, test_utils_int16_unaligned);
+
+    g_test_add_data_func ("/libqmi-glib/utils/uint32-LE",           LE, test_utils_uint32);
+    g_test_add_data_func ("/libqmi-glib/utils/uint32-BE",           BE, test_utils_uint32);
+    g_test_add_data_func ("/libqmi-glib/utils/int32-LE",            LE, test_utils_int32);
+    g_test_add_data_func ("/libqmi-glib/utils/int32-BE",            BE, test_utils_int32);
+    g_test_add_data_func ("/libqmi-glib/utils/uint32/unaligned-LE", LE, test_utils_uint32_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/uint32/unaligned-BE", BE, test_utils_uint32_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/int32/unaligned-LE",  LE, test_utils_int32_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/int32/unaligned-BE",  BE, test_utils_int32_unaligned);
+
+    g_test_add_data_func ("/libqmi-glib/utils/uint64-LE",           LE, test_utils_uint64);
+    g_test_add_data_func ("/libqmi-glib/utils/uint64-BE",           BE, test_utils_uint64);
+    g_test_add_data_func ("/libqmi-glib/utils/int64-LE",            LE, test_utils_int64);
+    g_test_add_data_func ("/libqmi-glib/utils/int64-BE",            BE, test_utils_int64);
+    g_test_add_data_func ("/libqmi-glib/utils/uint64/unaligned-LE", LE, test_utils_uint64_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/uint64/unaligned-BE", BE, test_utils_uint64_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/int64/unaligned-LE",  LE, test_utils_int64_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/int64/unaligned-BE",  BE, test_utils_int64_unaligned);
+
+    g_test_add_data_func ("/libqmi-glib/utils/uint-sized-LE",           LE, test_utils_uint_sized);
+    g_test_add_data_func ("/libqmi-glib/utils/uint-sized-BE",           BE, test_utils_uint_sized);
+    g_test_add_data_func ("/libqmi-glib/utils/uint-sized/unaligned-LE", LE, test_utils_uint_sized_unaligned);
+    g_test_add_data_func ("/libqmi-glib/utils/uint-sized/unaligned-BE", BE, test_utils_uint_sized_unaligned);
 
     return g_test_run ();
 }