diff --git a/bcm68620_release/release/host_driver/utils/Makefile b/bcm68620_release/release/host_driver/utils/Makefile
new file mode 100644
index 0000000..9c905ec
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/Makefile
@@ -0,0 +1,8 @@
+# Common utilities
+#
+MOD_NAME = utils
+MOD_TYPE = lib
+ifeq ("$(OS_KERNEL)", "linux")
+    MOD_DEPS = utils_linux
+endif
+srcs = bcmolt_utils.c bcmolt_buf.c bcmolt_bit_utils.c bcmolt_conv.c bcmolt_string.c
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_bit_utils.c b/bcm68620_release/release/host_driver/utils/bcmolt_bit_utils.c
new file mode 100644
index 0000000..130c07e
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_bit_utils.c
@@ -0,0 +1,370 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+
+#include "bcmos_system.h"
+#include "math.h"
+#include "bcmolt_bit_utils.h"
+
+
+/** dynamically allocate space for an array of `nbits' bits and initalize
+ *  the bits to all be zero.
+ *
+ * \param[out]  bv      pointer to a bit_vector struct.
+ * \param[in]   nbits   number of bits to allocate.
+ * \return      FALSE if space was not available, otherwise TRUE.
+ */
+bcmos_bool bcmolt_bv_new(bit_vector *bv, const uint32_t nbits)
+{
+    uint32_t nwords = BCMOS_DIVIDE_ROUND_UP(nbits, (BITS_SZ));
+
+    bv->nbits  = nbits;
+    bv->vector = (bv_bits *)calloc(nwords, sizeof(bv_bits));
+    return (bv->vector != NULL);
+}
+
+
+/** return the value of the `offset'th bit element of the bit vector.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   offset  offset of bit to test.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+bcmos_bool bcmolt_bv_get(const bit_vector *bv, const uint32_t offset)
+{
+    bcmos_bool    rv = BCMOS_FALSE;
+
+    if (offset <= bv->nbits)
+    {
+        rv = test_bits_set(bv->vector[(offset / BITS_SZ)],
+                           (1 << (offset % BITS_SZ)));
+    }
+    else
+    {
+        BCMOS_TRACE_ERR("out of range %u\n", offset);
+    }
+    return rv;
+}
+
+
+/** set or clear the bit in position `offset' of the bit vector.
+ *  bv->vector[bit_pos] is to be set (assigned to 1) if value is TRUE,
+ *  otherwise it is to be cleared (assigned to 0).
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   offset  offset of bit to set or clear.
+ * \param[in]   value   boolean value. TRUE for set, BCMOS_FALSE for clear.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+void bcmolt_bv_assign(bit_vector       *bv,
+                      const uint32_t    offset,
+                      const bcmos_bool  value)
+{
+    if (offset <= bv->nbits)
+    {
+        if (value)
+        {
+            bv->vector[offset / BITS_SZ] |= (1 << (offset % BITS_SZ));
+        }
+        else
+        {
+            bv->vector[offset / BITS_SZ] &= ~(1 << (offset % BITS_SZ));
+        }
+    }
+    else
+    {
+        BCMOS_TRACE_ERR("out of range %u\n", offset);
+    }
+}
+
+
+/** toggle the bit in position `offset' of the bit vector.
+ *  i.e. if it was 1 it is 0; if it was 0 it is 1.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   offset  offset of bit to toggle.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+void bcmolt_bv_toggle(bit_vector *bv, const uint32_t offset)
+{
+    if (offset <= bv->nbits)
+    {
+        bv->vector[offset / BITS_SZ] ^= (1 << (offset % BITS_SZ));
+    }
+    else
+    {
+        BCMOS_TRACE_ERR("out of range %u\n", offset);
+    }
+}
+
+
+/** copy bit vector from 'src' to 'dst'.
+ *
+ * \param[out]  dst     pointer to a bit_vector struct to copy to.
+ * \param[in]   src     pointer to a bit_vector struct to copy from.
+ * \param[in]   nbits   number of bits to copy.
+ * \return      none.
+ */
+void bcmolt_bv_copy(bit_vector        *dst, 
+                    const bit_vector  *src, 
+                    const uint32_t     nbits)
+{
+    uint32_t  i;
+    uint32_t  nwords    = nbits / BITS_SZ;
+    bv_bits   bit_remainder = nbits % BITS_SZ;
+
+    if ((nbits <= dst->nbits) && (nbits <= src->nbits))
+    {
+        for (i = 0; i < nwords; i++)
+        {
+            dst->vector[i] = src->vector[i];
+        }
+
+        if (0 != bit_remainder)
+        {
+            dst->vector[nwords] = (dst->vector[nwords] & ~((2^bit_remainder) - 1)) |
+                (src->vector[nwords] & ((2^bit_remainder) - 1));
+        }
+    }
+    else
+    {
+        BCMOS_TRACE_ERR("out of range %u\n", nbits);
+    }
+}
+
+
+/** Print bit pattern of word FORMATTED to string.
+ *
+ * \param[in]   value   value to transform to bit string.
+ * \param[in]   bitcnt  count of bits to be shown.
+ * \param[out]  outstr  pointer to a output buffer to store the string.
+ * \return      none
+ * \warning     this fn doesn't check the size of 'outstr'.
+ *              the caller should ensure 'outstr' has enough room for the
+ *              bit string, space characters and null terminator.
+ */
+void bcmolt_bit_string(const bv_bits value, const uint32_t bitcnt, char *outstr)
+{
+    uint32_t  offset;
+
+    if (bitcnt <= BITS_SZ)
+    {
+        for (offset = 0; offset < bitcnt; offset++)
+        {
+            *outstr++ = ((value >> offset) & 1) + '0';
+            if ((((offset + 1) % 4) == 0))
+            {
+                *outstr++ = ' ';
+            }
+        }
+    }
+
+    *outstr = '\0';
+}
+
+
+/** Print all bits in the bit vector.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \return      none.
+ */
+void bcmolt_bv_dump(const bit_vector *bv)
+{
+    uint32_t  idx;                        /* word idx */
+    char      outstr[BITS_SZ + 8 + 1];    /* 8 spaces + null */
+
+    for (idx = 0; idx < (bv->nbits / BITS_SZ); idx++)
+    {
+        bcmolt_bit_string(bv->vector[idx], BITS_SZ, outstr);
+        bcmos_printf("%s\n", outstr);
+    }
+
+    if (0 != (bv->nbits % BITS_SZ))
+    {
+        bcmolt_bit_string(bv->vector[idx], (bv->nbits % BITS_SZ), outstr);
+        bcmos_printf("%s\n", outstr);
+    }
+}
+
+
+/** Count the number of bits set in a long integer.
+ *
+ * \param[in]   num     integer value.
+ * \return      number of bits set.
+ */
+uint32_t bcmolt_bit_count(uint32_t num)
+{
+    num = ((num & 0xAAAAAAAAL) >>  1) + (num & 0x55555555L);
+    num = ((num & 0xCCCCCCCCL) >>  2) + (num & 0x33333333L);
+    num = ((num & 0xF0F0F0F0L) >>  4) + (num & 0x0F0F0F0FL);
+    num = ((num & 0xFF00FF00L) >>  8) + (num & 0x00FF00FFL);
+    num = ((num & 0xFFFF0000L) >> 16) + (num & 0x0000FFFFL);
+    return num;
+}
+
+
+/** Count the number of bits set in the whole bit vector.
+ *
+ * \param[in]   bv      pointer to the bit vector struct.
+ * \return      number of bits set.
+ */
+uint32_t bcmolt_bv_bit_count(const bit_vector *bv)
+{
+    uint32_t  nwords = BCMOS_DIVIDE_ROUND_UP(bv->nbits, (BITS_SZ));
+    uint32_t  cnt = 0;
+
+    while (0 != nwords--)
+    {
+        cnt += bcmolt_bit_count(bv->vector[nwords]);
+    }
+
+    return cnt;
+}
+
+
+
+/** Copy bit range from a 32-bit word array to an arbitrary bit position of
+ *  the destination 32-bit word array.
+ *
+ * \param[in]   dst             destination buffer
+ * \param[in]   dst_bytes       destination buffer size in bytes
+ * \param[in]   dst_bit_pos     least bit position to dest
+ * \param[in]   src             source buffer
+ * \param[in]   n_bits          how many bits to copy from source
+ * \note        src is in little endian and dst is in big endian.
+ */
+void bcmos_bit_range_set(uint32_t *dst, uint32_t dst_bytes, uint16_t dst_bit_pos,
+                         uint32_t *src, uint16_t n_bits)
+{
+    uint16_t    bp = dst_bit_pos;
+    uint16_t    len;
+    uint32_t    wp;
+    uint32_t    mask;
+    uint32_t    src_idx;
+    uint32_t    dst_idx;
+
+    wp = bp / 32;
+    bp = bp & (32 - 1);
+    src_idx = 0;
+
+    for (len = n_bits; len > 0; len -= 32)
+    {
+        if (bp != 0)
+        {
+            mask = (len < 32) ? (1 << len) - 1 : 0xFFFFFFFF;
+            dst_idx = wp;
+            dst[dst_idx] &= ~(mask << bp);
+            dst[dst_idx] |= src[src_idx] << bp;
+            wp++;
+            if (len > (32 - bp))
+            {
+                dst_idx = wp;
+                dst[dst_idx] &= ~(mask >> (32 - bp));
+                dst[dst_idx] |= src[src_idx] >> (32 - bp) & ((1 << bp) - 1);
+            }
+        }
+        else
+        {
+            dst_idx = wp;
+            if (len < 32)
+            {
+                mask = (1 << len) - 1;
+                dst[dst_idx] &= ~mask;
+                dst[dst_idx] |= src[src_idx] << bp;
+            }
+            else
+            {
+                dst[dst_idx] = src[src_idx];
+            }
+            wp++;
+        }
+        src_idx++;
+    }
+}
+
+
+/** Get bit range at an arbitrary bit position of a 32-bit word array
+ * 
+ * \param[in]   src             source buffer (e.g. dataport)
+ * \param[in]   src_bytes       source buffer size in bytes
+ * \param[in]   src_bit_pos     least bit position of the source
+ * \param[in]   dst             destination buffer to store the bit value
+ * \param[in]   n_bits          how many bits to copy from srouce
+ * \note        src is in big endian and dst is in little endian.
+ */
+void bcmos_bit_range_get(const uint32_t *src, uint32_t src_bytes,
+                         uint16_t src_bit_pos, uint32_t *dst, uint16_t n_bits)
+{
+    uint16_t    bp = src_bit_pos;   /* for readability */
+    uint16_t    len = n_bits;
+    uint32_t    wp;
+    uint32_t    src_idx;
+    uint32_t    dst_idx;
+
+    if (n_bits == 1)
+    {
+        wp = bp / 32;
+        bp = bp & (32 - 1);
+        src_idx = BCMOS_DIVIDE_ROUND_UP(src_bytes, 4) - 1 - wp;
+        dst[0] = ((src[src_idx] & (1 << bp)) != 0) ? 1: 0;
+        return;
+    }
+
+    wp = bp / 32;
+    bp = bp & (32 - 1);
+    dst_idx = 0;
+
+    for (; len > 0; len -= 32)
+    {
+        if (bp != 0)
+        {
+            src_idx = BCMOS_DIVIDE_ROUND_UP(src_bytes, 4) - 1 - wp;
+            dst[dst_idx] = src[src_idx] >> bp & ((1 << (32 - bp)) - 1);
+            wp++;
+            if (len > (32 - bp))
+            {
+                src_idx = BCMOS_DIVIDE_ROUND_UP(src_bytes, 4) - 1 - wp;
+                dst[dst_idx] |= src[src_idx] << (32 - bp);
+            }
+        }
+        else
+        {
+            src_idx = BCMOS_DIVIDE_ROUND_UP(src_bytes, 4) - 1 - wp;
+            dst[dst_idx] = src[src_idx];
+            wp++;
+        }
+
+        if (len < 32)
+        {
+            dst[dst_idx] &= ((1 << len) - 1);
+        }
+        dst_idx++;
+    }
+}
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_bit_utils.h b/bcm68620_release/release/host_driver/utils/bcmolt_bit_utils.h
new file mode 100644
index 0000000..9971292
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_bit_utils.h
@@ -0,0 +1,242 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+/**
+ * bcmolt_bit_utils.h
+ *  Created on: 03/10/2014
+ *      Author: cpark1
+ *
+ * This bit vector implementation is used for the EPON encryption.
+ * There is a certain hardware restriction that the global encryption mode
+ * can not be changed when a link encryption is configured for a different
+ * encryption mode.
+ * Likewise, the link encryption mode can not be changed if the global
+ * encryption mode is set to other mode.
+ * Therefore, when the host tries to change any of them, the OLT needs to
+ * check either the global encryption mode or the link encryption mode
+ * before applying the change.
+ * In the old implementation (like Pioneer), the firmware iterates through
+ * every link records of each PON port and check the encryption mode of each.
+ * This is very inefficient and time consuming.
+ * The host may want to know how many links are enabled for the encryption,
+ * or which link is enabled, etc.
+ * I thought that a bit vector implementation is best satisfies.
+ * Also, this implementation exactly reflects the IC implementation, so we
+ * can use it to mirror the hardware status.
+ *
+ */
+
+#ifndef BCMOLT_BIT_UTILS_H
+#define BCMOLT_BIT_UTILS_H
+
+
+#include "bcmos_system.h"
+
+
+/* the current (draft) design of the ASIC uses 32-bit bitmap data port */
+typedef uint32_t    bv_bits;
+
+typedef struct
+{
+    uint32_t  nbits;
+    bv_bits  *vector;
+} bit_vector;
+
+
+#define BITS_SZ     (sizeof(bv_bits) * CHAR_BIT)
+
+#define BITS_SET(val, mask) (((val) & (mask)) == (mask))
+
+/** Test if all given bits are set in the given data word
+ * \param[in]   word    Given data word to test
+ * \param[in]   mask    Test mask
+ * \return      TRUE if all the bits in the bitMask are set
+ */
+static inline bcmos_bool test_bits_set(uint32_t word, uint32_t mask)
+{
+    return ((word & mask) == mask);
+}
+
+/** Test if all given bits are clear in the given data word
+ * \param       word    Given word to test
+ * \param       mask Test mask
+ * \return      TRUE if all the bits given by bitMask are clear
+ */
+static inline bcmos_bool test_bits_clear(uint32_t word, uint32_t mask)
+{
+    return (word & mask) == 0;
+}
+
+/** Test whether any of the given bits are set in a value
+ * \param[in]   val     The value to test
+ * \param[in]   bits    The bits to test for
+ * \return      TRUE if any of the bits are set in the value, FALSE otherwise
+ */
+static inline bcmos_bool test_bits_any(uint32_t val, uint32_t bits)
+{
+    return (val & bits) != 0;
+}
+
+
+/** return true if only one bit is set for a given integer.
+ */
+static inline bcmos_bool is_one_bit_set(uint32_t number)
+{
+    return (number & (number - 1)) == 0;
+}
+
+
+
+/** dynamically allocate space for an array of `nbits' bits and initalize
+ *  the bits to all be zero.
+ *
+ * \param[out]  bv      pointer to a bit_vector struct.
+ * \param[in]   nbits   number of bits to allocate.
+ * \return      FALSE if space was not available, otherwise TRUE.
+ */
+bcmos_bool bcmolt_bv_new(bit_vector *bv, const uint32_t nbits);
+
+
+/** return the value of the `offset'th bit element of the bit vector.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   offset  offset of bit to test.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+bcmos_bool bcmolt_bv_get(const bit_vector *bv, const uint32_t offset);
+
+
+/** set or clear the bit in position `offset' of the bit vector.
+ *  bv->vector[bit_pos] is to be set (assigned to 1) if value is TRUE,
+ *  otherwise it is to be cleared (assigned to 0).
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   offset  offset of bit to set or clear.
+ * \param[in]   value   boolean value. TRUE for set, FALSE for clear.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+void bcmolt_bv_assign(bit_vector *bv, const uint32_t offset, const bcmos_bool value);
+
+
+/** set or clear 'nbits' bits of given bit vector.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   nbits   number of bits to set or clear.
+ * \param[in]   value   boolean value. TRUE for set, FALSE for clear.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+void bv_assign_nbits(bit_vector *bv, const uint32_t nbits,
+                     const bcmos_bool value);
+
+
+/** toggle the bit in position `offset' of the bit vector.
+ *  i.e. if it was 1 it is 0; if it was 0 it is 1.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \param[in]   offset  offset of bit to toggle.
+ * \return      FALSE if the bit offset is out of range, otherwise TRUE.
+ */
+void bcmolt_bv_toggle(bit_vector *bv, const uint32_t offset);
+
+
+/** copy bit vector from 'src' to 'dst'.
+ *
+ * \param[out]  dst     pointer to a bit_vector struct to copy to.
+ * \param[in]   src     pointer to a bit_vector struct to copy from.
+ * \param[in]   nbits   number of bits to copy.
+ * \return      none.
+ */
+void bcmolt_bv_copy(bit_vector *dst, const bit_vector *src, const uint32_t nbits);
+
+
+/** Print bit pattern of word FORMATTED to string.
+ *
+ * \param[in]   value   value to transform to bit string.
+ * \param[in]   bitcnt  count of bits to be shown.
+ * \param[out]  outstr  pointer to a output buffer to store the string.
+ * \return      none
+ * \warning     this fn doesn't check the size of 'outstr'.
+ *              the caller should ensure 'outstr' has enough room for the
+ *              bit string, space characters and null terminator.
+ */
+void bcmolt_bit_string(const bv_bits value, const uint32_t bitcnt, char *outstr);
+
+
+/** Print all bits in the bit vector.
+ *
+ * \param[in]   bv      pointer to a bit_vector struct.
+ * \return      none.
+ */
+void bcmolt_bv_dump(const bit_vector *bv);
+
+
+/** Count the number of bits set in a long integer.
+ *
+ * \param[in]   num     integer value.
+ * \return      number of bits set.
+ */
+uint32_t bcmolt_bit_count(uint32_t num);
+
+
+/** Count the number of bits set in the whole bit vector.
+ *
+ * \param[in]   bv      pointer to the bit vector struct.
+ * \return      number of bits set.
+ */
+uint32_t bcmolt_bv_bit_count(const bit_vector *bv);
+
+
+/** Copy bit range from a 32-bit word array to an arbitrary bit position of
+ *  the destination 32-bit word array.
+ *
+ * \param[in]   dst             destination buffer
+ * \param[in]   dst_bytes       destination buffer size in bytes
+ * \param[in]   dst_bit_pos     least bit position to dest
+ * \param[in]   src             source buffer
+ * \param[in]   src_bits        many bits to copy from source
+ * \note        src is in little endian and dst is in big endian.
+ */
+void bcmos_bit_range_set(uint32_t *dst, uint32_t dst_bytes, uint16_t dst_bit_pos,
+                         uint32_t *src, uint16_t n_bits);
+
+/** Get bit range at an arbitrary bit position of a 32-bit word array
+ *
+ * \param[in]   src             source buffer (e.g. dataport)
+ * \param[in]   src_bytes       source buffer size in bytes
+ * \param[in]   src_bit_pos     least bit position of the source
+ * \param[in]   dst             destination buffer to store the bit value
+ * \param[in]   n_bits          how many bits to copy from srouce
+ * \note        src is in big endian and dst is in little endian.
+ */
+void bcmos_bit_range_get(const uint32_t *src, uint32_t src_bytes,
+                         uint16_t src_bit_pos, uint32_t *dst, uint16_t n_bits);
+
+
+#endif  /* BCMOLT_BIT_UTILS_H */
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_buf.c b/bcm68620_release/release/host_driver/utils/bcmolt_buf.c
new file mode 100644
index 0000000..cb57fe9
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_buf.c
@@ -0,0 +1,247 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#include "bcmolt_buf.h"
+#include "bcmos_system.h"
+
+/** Initalize a bcmolt_buf stream
+ *
+ * \param buf 
+ * \param size 
+ * \param start
+ * \param endian Endianness of numbers in the resulting stream
+ */
+void bcmolt_buf_init(bcmolt_buf *buf, uint32_t size, uint8_t *start, bcmos_endian endian)
+{
+    buf->len = size;
+    buf->curr = start;
+    buf->start = start;
+    buf->free = NULL;
+    buf->bh = NULL;
+    /* Currently, we only support reading/writing numbers in a single endianness. */
+    BUG_ON(endian != BCMOLT_BUF_ENDIAN_FIXED);
+}
+
+/** Allocate data buffer and initialize bcmolt_buf stream
+ *
+ * \param buf
+ * \param size
+ * \param endian Endianness of numbers in the resulting stream
+ * \return BCM_ERR_OK or BCM_ERR_NOMEM
+ */
+bcmos_errno bcmolt_buf_alloc(bcmolt_buf *buf, uint32_t size, bcmos_endian endian)
+{
+    buf->start = bcmos_alloc(size);
+    if (buf->start == NULL)
+    {
+        return BCM_ERR_NOMEM;
+    }
+    bcmolt_buf_init(buf, size, buf->start, endian);
+    return BCM_ERR_OK;
+}
+
+/** Release data buffer pointed by bcmolt_buf stream
+ * \param[in,out] buf
+ */
+void bcmolt_buf_free(bcmolt_buf *buf)
+{
+    if (buf->start != NULL)
+    {
+        if (buf->free)
+        {
+            buf->free(buf->bh);
+            buf->free = NULL;
+            buf->bh = NULL;
+        }
+        else
+        {
+            bcmos_free(buf->start);
+        }
+        buf->start = NULL;
+    }
+    buf->len = 0;
+    buf->curr = NULL;
+}
+
+/** Read from the buffer
+ *
+ * \param buf    bcmolt_buf instance
+ * \param to     Where to read to
+ * \param len    Number of bytes to copy
+ *
+ * \return       BCMOS_TRUE if successfully copied
+ */
+bcmos_bool bcmolt_buf_read(bcmolt_buf *buf, void *to, size_t len)
+{
+    if ((buf->start + buf->len) >= (buf->curr + len))
+    {
+        memcpy(to, buf->curr, len);
+        buf->curr += len;
+        return BCMOS_TRUE;
+    }
+
+    return BCMOS_FALSE;
+}
+
+/** Transfer bytes from one buf to another
+ *
+ * \param *from    Source buffer
+ * \param *to      Destination buffer
+ * \param bytes    Number of bytes to transfer
+ * \return         BCMOS_TRUE if successfully transferred
+ */
+bcmos_bool bcmolt_buf_transfer_bytes(bcmolt_buf *from, bcmolt_buf *to, uint32_t bytes)
+{
+    uint8_t tmp[256];
+    uint32_t toRead;
+    while (bytes != 0)
+    {
+        toRead = bytes > sizeof(tmp) ? sizeof(tmp) : bytes;
+        if (!bcmolt_buf_read(from, tmp, toRead) || !bcmolt_buf_write(to, tmp, toRead))
+        {
+            return BCMOS_FALSE;
+        }
+
+        bytes -= toRead;
+    }
+
+    return BCMOS_TRUE;
+}
+
+/** Write to the buffer
+ *
+ * \param buf    bcmolt_buf instance
+ * \param from   Source, to copy from
+ * \param len    Number of bytes to copy
+ *
+ * \return       BCMOS_TRUE if successfully copied
+ */
+bcmos_bool bcmolt_buf_write(bcmolt_buf *buf, const void *from, size_t len)
+{
+    if ((buf->start + buf->len) >= (buf->curr + len))
+    {
+        memcpy(buf->curr, from, len);
+        buf->curr += len;
+        return BCMOS_TRUE;
+    }
+    else
+    {
+        return BCMOS_FALSE;
+    }
+}
+
+/** Move the current pointer to a given position in the buffer
+ *
+ * \param pos    Byte position in the buffer to move the current pointer to
+ *
+ * \param *buf   Input buffer
+ * \return       BCMOS_FALSE if len takes us past the end of buffer
+ */
+bcmos_bool bcmolt_buf_set_pos(bcmolt_buf *buf, uint32_t pos)
+{
+    if (pos <= buf->len)
+    {
+        buf->curr = buf->start + pos;
+        return BCMOS_TRUE;
+    }
+
+    return BCMOS_FALSE;
+}
+
+/** Move the current pointer ahead by given number of bytes
+ *
+ * \param buf    bcmolt_buf instance
+ * \param len    Number of bytes to skip
+ *
+ * \return       BCMOS_FALSE if len takes us past the end of buffer
+ */
+bcmos_bool bcmolt_buf_skip(bcmolt_buf *buf, uint32_t len)
+{
+    if ((buf->start + buf->len) >= (buf->curr + len))
+    {
+        buf->curr += len;
+        return BCMOS_TRUE;
+    }
+
+    return BCMOS_FALSE;
+}
+
+/** Move the current pointer back by given number of bytes
+ *
+ * \param buf    bcmolt_buf instance
+ * \param len    Number of bytes to go back
+ *
+ * \return       BCMOS_FALSE if len takes us past the start of buffer
+ */
+bcmos_bool bcmolt_buf_rewind(bcmolt_buf *buf, uint32_t len)
+{
+    if (buf->curr >= (buf->start + len))
+    {
+        buf->curr -= len;
+        return BCMOS_TRUE;
+    }
+
+    return BCMOS_FALSE;
+}
+
+/** Reads a boolean from a buffer
+ *
+ * \param *buf
+ * \param *val
+ */
+bcmos_bool bcmolt_buf_read_bool(bcmolt_buf *buf, bcmos_bool *val)
+{
+    /* this function isn't inlined like the rest because it's too complex to inline cleanly */
+    uint8_t tmp;
+    if (bcmolt_buf_read_u8(buf, &tmp))
+    {
+        *val = (tmp != 0);
+        return BCMOS_TRUE;
+    }
+    else
+    {
+        return BCMOS_FALSE;
+    }
+}
+
+
+#ifdef __KERNEL__
+EXPORT_SYMBOL(bcmolt_buf_init);
+EXPORT_SYMBOL(bcmolt_buf_alloc);
+EXPORT_SYMBOL(bcmolt_buf_free);
+EXPORT_SYMBOL(bcmolt_buf_read);
+EXPORT_SYMBOL(bcmolt_buf_transfer_bytes);
+EXPORT_SYMBOL(bcmolt_buf_write);
+EXPORT_SYMBOL(bcmolt_buf_set_pos);
+EXPORT_SYMBOL(bcmolt_buf_skip);
+EXPORT_SYMBOL(bcmolt_buf_rewind);
+EXPORT_SYMBOL(bcmolt_buf_read_bool);
+
+MODULE_LICENSE("Dual BSD/GPL");
+#endif
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_buf.h b/bcm68620_release/release/host_driver/utils/bcmolt_buf.h
new file mode 100644
index 0000000..206337a
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_buf.h
@@ -0,0 +1,733 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#ifndef BCMOLT_BUF_H_
+#define BCMOLT_BUF_H_
+
+#include "bcmos_system.h"
+
+/** Generic memory stream object */
+typedef struct bcmolt_buf bcmolt_buf;
+
+struct bcmolt_buf
+{
+    uint8_t *start;  /**< Pointer to the start of the buffer */
+    uint8_t *curr;   /**< Pointer to the current position in the buffer */
+    uint32_t len;    /**< Total Length of buffer */
+    /* The following 2 fields enable foreign buffer encapsulation */
+    void (*free)(void *bh);  /**< Foreign buffer release callback */
+    void *bh;        /**< Foreign buffer handle */
+};
+
+/* Serialization buffer endianness */
+#define BCMOLT_BUF_ENDIAN_FIXED BCMOS_ENDIAN_BIG
+
+#if BCMOLT_BUF_ENDIAN_FIXED == BCMOS_ENDIAN_BIG
+    #define BCMOLT_BUF_ENDIAN_BUF_TO_CPU(size, n) BCMOS_ENDIAN_BIG_TO_CPU_##size(n)
+    #define BCMOLT_BUF_ENDIAN_CPU_TO_BUF(size, n) BCMOS_ENDIAN_CPU_TO_BIG_##size(n)
+#else
+    #define BCMOLT_BUF_ENDIAN_BUF_TO_CPU(size, n) BCMOS_ENDIAN_LITTLE_TO_CPU_##size(n)
+    #define BCMOLT_BUF_ENDIAN_CPU_TO_BUF(size, n) BCMOS_ENDIAN_CPU_TO_LITTLE_##size(n)
+#endif
+
+/** Initalize a bcmolt_buf stream
+ *
+ * \param buf
+ * \param size
+ * \param start
+ * \param endian Endianness of numbers in the resulting stream.
+ *               This parameter is only for sanity check. Buffer endianness is
+ *               set at compile time. Application MUST NOT rely on default buffer endianness
+ *               being Big Endian.
+ *               If Big Endian buffer is required, application must use
+ *               access functions with "_be" designator (bcmolt_buf_read_u16_be(), etc.)
+ */
+void bcmolt_buf_init(bcmolt_buf *buf, uint32_t size, uint8_t *start, bcmos_endian endian);
+
+/** Allocate data buffer and initialize bcmolt_buf stream
+ *
+ * \param buf
+ * \param size
+ * \param endian Endianness of numbers in the resulting stream.
+ *               See explanation in bcmolt_buf_alloc()
+ * \return BCM_ERR_OK or BCM_ERR_NOMEM
+ */
+bcmos_errno bcmolt_buf_alloc(bcmolt_buf *buf, uint32_t size, bcmos_endian endian);
+
+/** Release data buffer pointed by bcmolt_buf stream
+ * \param[in,out] buf
+ */
+void bcmolt_buf_free(bcmolt_buf *buf);
+
+/** Read from the buffer
+ *
+ * \param buf    bcmolt_buf instance
+ * \param to     Where to read to
+ * \param len    Number of bytes to copy
+ *
+ * \return       BCMOS_TRUE if successfully copied
+ */
+bcmos_bool bcmolt_buf_read(bcmolt_buf *buf, void *to, size_t len);
+
+/** Transfer bytes from one buf to another
+ *
+ * \param *from    Source buffer
+ * \param *to      Destination buffer
+ * \param bytes    Number of bytes to transfer
+ * \return         BCMOS_TRUE if successfully transferred
+ */
+bcmos_bool bcmolt_buf_transfer_bytes(bcmolt_buf *from, bcmolt_buf *to, uint32_t bytes);
+
+/** Write to the buffer
+ *
+ * \param buf    bcmolt_buf instance
+ * \param from   Source, to copy from
+ * \param len    Number of bytes to copy
+ *
+ * \return       BCMOS_TRUE if successfully copied
+ */
+bcmos_bool bcmolt_buf_write(bcmolt_buf *buf, const void *from, size_t len);
+
+/** Move the current pointer to a given position in the buffer
+ *
+ * \param pos    Byte position in the buffer to move the current pointer to
+ *
+ * \param *buf   Input buffer
+ * \return       BCMOS_FALSE if len takes us past the end of buffer
+ */
+bcmos_bool bcmolt_buf_set_pos(bcmolt_buf *buf, uint32_t pos);
+
+/** Move the current pointer ahead by given number of bytes
+ *
+ * \param buf    bcmolt_buf instance
+ * \param len    Number of bytes to skip
+ *
+ * \return       BCMOS_FALSE if len takes us past the end of buffer
+ */
+bcmos_bool bcmolt_buf_skip(bcmolt_buf *buf, uint32_t len);
+
+/** Move the current pointer back by given number of bytes
+ *
+ * \param buf    bcmolt_buf instance
+ * \param len    Number of bytes to go back
+ *
+ * \return       BCMOS_FALSE if len takes us past the start of buffer
+ */
+bcmos_bool bcmolt_buf_rewind(bcmolt_buf *buf, uint32_t len);
+
+/** Get the current buffer pointer
+ *
+ * \param buf   bcmolt_buf instance
+ *
+ * \return      the current buffer pointer
+ */
+static inline uint8_t *bcmolt_buf_snap_get(const bcmolt_buf *buf)
+{
+    return buf->curr;
+}
+
+/** Move the current pointer to a snapped location
+ *
+ * \param buf   bcmolt_buf instance
+ * \param snap  snapped location
+ */
+static inline void bcmolt_buf_snap_restore(bcmolt_buf *buf, uint8_t *snap)
+{
+    buf->curr = snap;
+}
+
+/** Get the length of unprocessed bytes in given stream
+ *
+ * \param buf    Input buffer
+ *
+ * \return       The number of remaining bytes in the buffer
+ */
+static inline uint32_t bcmolt_buf_get_remaining_size(const bcmolt_buf *buf)
+{
+    return (uint32_t)((buf->start + buf->len) - buf->curr);
+}
+
+/** Get amount of buf that has been read or written so far
+ *
+ * \param buf     Input buffer
+ * \return        Amount of buffer used
+ */
+static inline uint32_t bcmolt_buf_get_used(const bcmolt_buf *buf)
+{
+    return (uint32_t)(buf->curr - buf->start);
+}
+
+/** Reads a uint8_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint8_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u8(bcmolt_buf *buf, uint8_t *val)
+{
+    return bcmolt_buf_read(buf, val, sizeof(*val));
+}
+
+/** Writes a uint8_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint8_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u8(bcmolt_buf *buf, uint8_t val)
+{
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Reads a boolean from a buffer
+ *
+ * \param *buf
+ * \param *val
+ */
+bcmos_bool bcmolt_buf_read_bool(bcmolt_buf *buf, bcmos_bool *val);
+
+/** Writes a bcmos_bool to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint8_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_bool(bcmolt_buf *buf, bcmos_bool val)
+{
+    return bcmolt_buf_write_u8(buf, val ? 1 : 0);
+}
+
+/** Reads a int8_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int8_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s8(bcmolt_buf *buf, int8_t *val)
+{
+    return bcmolt_buf_read_u8(buf, (uint8_t *)val);
+}
+
+/** Writes a int8_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int8_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s8(bcmolt_buf *buf, int8_t val)
+{
+    return bcmolt_buf_write_u8(buf, (uint8_t)val);
+}
+
+/** Reads a uint16_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint16_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u16(bcmolt_buf *buf, uint16_t *val)
+{
+    bcmos_bool res = bcmolt_buf_read(buf, val, sizeof(*val));
+    *val = BCMOLT_BUF_ENDIAN_BUF_TO_CPU(U16, *val);
+    return res;
+}
+
+/** Reads a uint16_t from a Big Endian buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint16_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u16_be(bcmolt_buf *buf, uint16_t *val)
+{
+    bcmos_bool res = bcmolt_buf_read(buf, val, sizeof(*val));
+    *val = BCMOS_ENDIAN_BIG_TO_CPU_U16(*val);
+    return res;
+}
+
+/** Writes a uint16_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint16_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u16(bcmolt_buf *buf, uint16_t val)
+{
+    val = BCMOLT_BUF_ENDIAN_CPU_TO_BUF(U16, val);
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Writes a uint16_t to a Big Endian buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint16_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u16_be(bcmolt_buf *buf, uint16_t val)
+{
+    val = BCMOS_ENDIAN_CPU_TO_BIG_U16(val);
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Reads a int16_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int16_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s16(bcmolt_buf *buf, int16_t *val)
+{
+    return bcmolt_buf_read_u16(buf, (uint16_t *)val);
+}
+
+/** Reads a int16_t from a Big Endian buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int16_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s16_be(bcmolt_buf *buf, int16_t *val)
+{
+    return bcmolt_buf_read_u16_be(buf, (uint16_t *)val);
+}
+
+/** Writes int16_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int16_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s16(bcmolt_buf *buf, int16_t val)
+{
+    return bcmolt_buf_write_u16(buf, (uint16_t)val);
+}
+
+/** Writes int16_t to a Big Endian buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int16_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s16_be(bcmolt_buf *buf, int16_t val)
+{
+    return bcmolt_buf_write_u16_be(buf, (uint16_t)val);
+}
+
+/** Reads a bcmos_u24 from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val bcmos_u24 to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u24(bcmolt_buf *buf, uint24_t *val)
+{
+    return bcmolt_buf_read_u8(buf, &(val->low_hi.hi)) &&
+           bcmolt_buf_read_u8(buf, &(val->low_hi.mid)) &&
+           bcmolt_buf_read_u8(buf, &(val->low_hi.low));
+}
+
+/** Writes a bcmos_u24 to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    bcmos_u24 to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u24(bcmolt_buf *buf, uint24_t val)
+{
+    return bcmolt_buf_write_u8(buf, val.low_hi.hi) &&
+           bcmolt_buf_write_u8(buf, val.low_hi.mid) &&
+           bcmolt_buf_write_u8(buf, val.low_hi.low);
+}
+
+/** Reads a uint32_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint32_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u32(bcmolt_buf *buf, uint32_t *val)
+{
+    bcmos_bool res = bcmolt_buf_read(buf, val, sizeof(*val));
+    *val = BCMOLT_BUF_ENDIAN_BUF_TO_CPU(U32, *val);
+    return res;
+}
+
+/** Reads a uint32_t from a Big Endian buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint32_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u32_be(bcmolt_buf *buf, uint32_t *val)
+{
+    bcmos_bool res = bcmolt_buf_read(buf, val, sizeof(*val));
+    *val = BCMOS_ENDIAN_BIG_TO_CPU_U32(*val);
+    return res;
+}
+
+/** Writes a uint32_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint32_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u32(bcmolt_buf *buf, uint32_t val)
+{
+    val = BCMOLT_BUF_ENDIAN_CPU_TO_BUF(U32, val);
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Writes a uint32_t to a Big Endian buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint32_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u32_be(bcmolt_buf *buf, uint32_t val)
+{
+    val = BCMOS_ENDIAN_CPU_TO_BIG_U32(val);
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Reads a int32_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int32_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s32(bcmolt_buf *buf, int32_t *val)
+{
+    return bcmolt_buf_read_u32(buf, (uint32_t *)val);
+}
+
+/** Reads a int32_t from a big endian buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int32_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s32_be(bcmolt_buf *buf, int32_t *val)
+{
+    return bcmolt_buf_read_u32_be(buf, (uint32_t *)val);
+}
+
+/** Writes a int32_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int32_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s32(bcmolt_buf *buf, int32_t val)
+{
+    return bcmolt_buf_write_u32(buf, (uint32_t)val);
+}
+
+/** Writes a int32_t to a Big Endian buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int32_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s32_be(bcmolt_buf *buf, int32_t val)
+{
+    return bcmolt_buf_write_u32_be(buf, (uint32_t)val);
+}
+
+/** Reads a uint64_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint64_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u64(bcmolt_buf *buf, uint64_t *val)
+{
+    bcmos_bool res = bcmolt_buf_read(buf, val, sizeof(*val));
+    *val = BCMOLT_BUF_ENDIAN_BUF_TO_CPU(U64, *val);
+    return res;
+}
+
+/** Reads a uint64_t from a Big Endian buffer
+ *
+ * \param buf Buffer to read from
+ * \param val uint64_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_u64_be(bcmolt_buf *buf, uint64_t *val)
+{
+    bcmos_bool res = bcmolt_buf_read(buf, val, sizeof(*val));
+    *val = BCMOS_ENDIAN_BIG_TO_CPU_U64(*val);
+    return res;
+}
+
+/** Writes a uint64_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint64_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u64(bcmolt_buf *buf, uint64_t val)
+{
+    val = BCMOLT_BUF_ENDIAN_CPU_TO_BUF(U64, val);
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Writes a uint64_t to a Big Endian buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    uint64_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_u64_be(bcmolt_buf *buf, uint64_t val)
+{
+    val = BCMOS_ENDIAN_CPU_TO_BIG_U64(val);
+    return bcmolt_buf_write(buf, &val, sizeof(val));
+}
+
+/** Reads a int64_t from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int64_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s64(bcmolt_buf *buf, int64_t *val)
+{
+    return bcmolt_buf_read_u64(buf, (uint64_t *)val);
+}
+
+/** Reads a int64_t from a Big Endian buffer
+ *
+ * \param buf Buffer to read from
+ * \param val int64_t to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_s64_be(bcmolt_buf *buf, int64_t *val)
+{
+    return bcmolt_buf_read_u64_be(buf, (uint64_t *)val);
+}
+
+/** Writes a int64_t to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int64_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s64(bcmolt_buf *buf, int64_t val)
+{
+    return bcmolt_buf_write_u64(buf, (uint64_t)val);
+}
+
+/** Writes a int64_t to a Big Endian buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    int64_t to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_s64_be(bcmolt_buf *buf, int64_t val)
+{
+    return bcmolt_buf_write_u64_be(buf, (uint64_t)val);
+}
+
+/** Reads a float from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val float to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_float(bcmolt_buf *buf, float *val)
+{
+    return bcmolt_buf_read_u32(buf, (uint32_t *)val);
+}
+
+/** Writes a float to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    float to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_float(bcmolt_buf *buf, float val)
+{
+    uint32_t *num = (uint32_t *)&val;
+    return bcmolt_buf_write_u32(buf, *num);
+}
+
+/** Reads a double from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val double to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_double(bcmolt_buf *buf, double *val)
+{
+    return bcmolt_buf_read_u64(buf, (uint64_t *)val);
+}
+
+/** Writes a double to a buffer
+ *
+ * \param buf    Buffer to write to
+ * \param val    double to write
+ *
+ * \return       BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_double(bcmolt_buf *buf, double val)
+{
+    uint64_t *num = (uint64_t *)&val;
+    return bcmolt_buf_write_u64(buf, *num);
+}
+
+/** Reads a bcmos_vlan_tag from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val bcmos_vlan_tag to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_vlan_tag(bcmolt_buf *buf, bcmos_vlan_tag *val)
+{
+    return bcmolt_buf_read_u16(buf, (uint16_t *)val);
+}
+
+/** Writes a bcmos_vlan_tag to a buffer
+ *
+ * \param buf Buffer to write to
+ * \param val bcmos_vlan_tag to write
+ *
+ * \return BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_vlan_tag(bcmolt_buf *buf, bcmos_vlan_tag val)
+{
+    return bcmolt_buf_write_u16(buf, (uint16_t)val);
+}
+
+/** Reads a bcmos_mac_address from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val bcmos_mac_address to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_mac_address(bcmolt_buf *buf, bcmos_mac_address *val)
+{
+    return bcmolt_buf_read(buf, val, sizeof(bcmos_mac_address));
+}
+
+/** Writes a bcmos_mac_address to a buffer
+ *
+ * \param buf Buffer to write to
+ * \param val bcmos_mac_address to write
+ *
+ * \return BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_mac_address(bcmolt_buf *buf, bcmos_mac_address val)
+{
+    return bcmolt_buf_write(buf, &val, sizeof(bcmos_mac_address));
+}
+
+/** Reads a bcmos_ipv4_address from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val bcmos_ipv4_address to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_ipv4_address(bcmolt_buf *buf, bcmos_ipv4_address *val)
+{
+    return bcmolt_buf_read(buf, val->u8, sizeof(bcmos_ipv4_address));
+}
+
+/** Writes a bcmos_ipv4_address to a buffer
+ *
+ * \param buf Buffer to write to
+ * \param val bcmos_ipv4_address to write
+ *
+ * \return BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_ipv4_address(bcmolt_buf *buf, bcmos_ipv4_address val)
+{
+    return bcmolt_buf_write(buf, val.u8, sizeof(bcmos_ipv4_address));
+}
+
+/** Reads a bcmos_ipv6_address from a buffer
+ *
+ * \param buf Buffer to read from
+ * \param val bcmos_ipv6_address to read
+ *
+ * \return BCMOS_TRUE if read successful
+ */
+static inline bcmos_bool bcmolt_buf_read_ipv6_address(bcmolt_buf *buf, bcmos_ipv6_address *val)
+{
+    return bcmolt_buf_read(buf, *val, sizeof(bcmos_ipv6_address));
+}
+
+/** Writes a bcmos_ipv6_address to a buffer
+ *
+ * \param buf Buffer to write to
+ * \param val bcmos_ipv6_address to write
+ *
+ * \return BCMOS_TRUE if write successful
+ */
+static inline bcmos_bool bcmolt_buf_write_ipv6_address(bcmolt_buf *buf, bcmos_ipv6_address val)
+{
+    return bcmolt_buf_write(buf, val, sizeof(bcmos_ipv6_address));
+}
+
+#endif /* BCMOLT_BUF_H_ */
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_conv.c b/bcm68620_release/release/host_driver/utils/bcmolt_conv.c
new file mode 100644
index 0000000..7472c21
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_conv.c
@@ -0,0 +1,59 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#include <bcmos_system.h>
+#include <bcmolt_utils.h>
+#include "bcmolt_conv.h"
+
+char *bcmolt_strftime(char *time_str, time_t t, const char *timezone_str)
+{
+    struct tm ts;
+    int32_t tz_hour;
+    uint32_t tz_min;
+    
+    ts = *localtime(&t);
+    if (timezone_str && *timezone_str)
+    {
+        if (sscanf(timezone_str, "%03d:%02u", &tz_hour, &tz_min) < 2)
+        {
+            tz_hour = 0;
+            tz_min = 0;
+        }
+        else
+        {
+            ts.tm_hour += tz_hour;
+            ts.tm_min += tz_min;
+        }
+    }
+
+    strftime(time_str, BCMOLT_TIME_STR_MAX_LEN, "%a %Y-%m-%d %H:%M:%S", &ts);
+
+    return time_str;
+}
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_conv.h b/bcm68620_release/release/host_driver/utils/bcmolt_conv.h
new file mode 100644
index 0000000..50c8a0b
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_conv.h
@@ -0,0 +1,186 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#ifndef _BCMOLT_CONV_H_
+#define _BCMOLT_CONV_H_
+
+#ifndef CFE_BUILD
+#include <bcmolt_utils.h>
+#endif
+
+/* Macro for generating a generic conversion from type A to type B.
+ * Example:
+ *
+ *      BCMOLT_TYPE2TYPE(bws_dba_control_id, bws_dba_control_cb, static)
+ *
+ * will expand to:
+ *
+ *     typedef struct
+ *     {
+ *         bws_dba_control_id from;
+ *         bws_dba_control_cb to;
+ *     }
+ *     bws_dba_control_id2bws_dba_control_cb_t;
+ *     
+ *     static bws_dba_control_id2bws_dba_control_cb_t bws_dba_control_id2bws_dba_control_cb[];
+ *     
+ *     static inline bws_dba_control_cb bws_dba_control_id2bws_dba_control_cb_conv(bws_dba_control_id from)
+ *     {
+ *         const bws_dba_control_id2bws_dba_control_cb_t *arr = bws_dba_control_id2bws_dba_control_cb;
+ *         for (; arr->from != (bws_dba_control_id)-1 && arr->from != from; arr++);
+ *         return arr->to;
+ *     }
+ */
+#define BCMOLT_TYPE2TYPE(from_type, to_type, scope) \
+    typedef struct \
+    { \
+        from_type from; \
+        to_type to; \
+    } \
+    from_type##2##to_type##_t; \
+    scope from_type##2##to_type##_t from_type##2##to_type[]; \
+    static inline to_type from_type##2##to_type##_conv(from_type from) \
+    { \
+        const from_type##2##to_type##_t *arr = from_type##2##to_type; \
+        for (; arr->from != (from_type)-1 && arr->from != from; arr++); \
+        return arr->to; \
+    }
+
+/* Macro for generating a generic conversion from type A to a constant string.
+ * Example:
+ *
+ *      BCMOLT_TYPE2STR(pon_mode, extern)
+ *
+ * will expand to:
+ *
+ *     typedef struct
+ *     {
+ *         pon_mode from;
+ *         const char *to;
+ *     }
+ *     pon_mode2str_t;
+ *
+ *     extern pon_mode2str_t pon_mode2str[];
+ *
+ *     static inline const char *pon_mode2str_conv(pon_mode from)
+ *     {
+ *         const pon_mode2str_t *arr = pon_mode2str;
+ *         for (; arr->from != (pon_mode)-1 && arr->from != from; arr++);
+ *         return arr->to;
+ *     }
+ */
+#define BCMOLT_TYPE2STR(from_type, scope) \
+    typedef struct \
+    { \
+        from_type from; \
+        const char *to; \
+    } \
+    from_type##2str_t; \
+    scope from_type##2str_t from_type##2str[]; \
+    static inline const char *from_type##2str_conv(from_type from) \
+    { \
+        const from_type##2str_t *arr = from_type##2str; \
+        for (; arr->from != (from_type)-1 && arr->from != from; arr++); \
+        return arr->to; \
+    }
+
+/* Macro for generating a generic conversion from type A to an integer.
+ * Example:
+ *
+ *      BCMOLT_TYPE2INT(ploam_ds_gpon_message_id, repetitions, extern)
+ *
+ * will expand to:
+ * 
+ *     typedef struct
+ *     {
+ *         ploam_ds_gpon_message_id from;
+ *         int to;
+ *     }
+ *     ploam_ds_gpon_message_id2repetitions_t;
+ *
+ *     extern ploam_ds_gpon_message_id2repetitions_t ploam_ds_gpon_message_id2repetitions[];
+ *
+ *     static inline int ploam_ds_gpon_message_id2repetitions_conv(ploam_ds_gpon_message_id from)
+ *     {
+ *         const ploam_ds_gpon_message_id2repetitions_t *arr = ploam_ds_gpon_message_id2repetitions;
+ *         for (; arr->from != (ploam_ds_gpon_message_id)-1 && arr->from != from; arr++);
+ *         return arr->to;
+ *     }
+ */
+#define BCMOLT_TYPE2INT(from_type, to_name, scope) \
+    typedef struct \
+    { \
+        from_type from; \
+        int to; \
+    } \
+    from_type##2##to_name##_t; \
+    scope from_type##2##to_name##_t from_type##2##to_name[]; \
+    static inline int from_type##2##to_name##_conv(from_type from) \
+    { \
+        const from_type##2##to_name##_t *arr = from_type##2##to_name; \
+        for (; arr->from != (from_type)-1 && arr->from != from; arr++); \
+        return arr->to; \
+    }
+
+/* Although we have BCMOLT_TYPE2STR, int2str_t is still required when the same generic pointer needs to point to 2 different types (e.g: one specific for GPON and
+ * the other specific for XGPON). */
+typedef struct
+{
+    int from;
+    const char *to;
+}
+int2str_t;
+
+static inline const char *int2str(const int2str_t *arr, int from)
+{
+    for (; arr->from != -1 && arr->from != from; arr++);
+    return arr->to;
+}
+
+/* Although we have BCMOLT_TYPE2INT, int2int_t is still required when the same generic pointer needs to point to 2 different types (e.g: one specific for GPON and
+ * the other specific for XGPON). */
+typedef struct
+{
+    int from;
+    int to;
+}
+int2int_t;
+
+static inline int int2int(const int2int_t *arr, int from)
+{
+    for (; arr->from != -1 && arr->from != from; arr++);
+    return arr->to;
+}
+
+#ifndef CFE_BUILD
+char *bcmolt_strftime(char *time_str, time_t t, const char *timezone_str);
+#endif
+
+#endif
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_firmware_envelope.h b/bcm68620_release/release/host_driver/utils/bcmolt_firmware_envelope.h
new file mode 100644
index 0000000..fd4d6d0
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_firmware_envelope.h
@@ -0,0 +1,95 @@
+/*
+<:copyright-BRCM:2016:proprietary:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+This program is the proprietary software of Broadcom Corporation and/or its
+licensors, and may only be used, duplicated, modified or distributed pursuant
+to the terms and conditions of a separate, written license agreement executed
+between you and Broadcom (an "Authorized License").  Except as set forth in
+an Authorized License, Broadcom grants no license (express or implied), right
+to use, or waiver of any kind with respect to the Software, and Broadcom
+expressly reserves all rights in and to the Software and all intellectual
+property rights therein.  IF YOU HAVE NO AUTHORIZED LICENSE, THEN YOU HAVE
+NO RIGHT TO USE THIS SOFTWARE IN ANY WAY, AND SHOULD IMMEDIATELY NOTIFY
+BROADCOM AND DISCONTINUE ALL USE OF THE SOFTWARE.
+
+Except as expressly set forth in the Authorized License,
+
+1. This program, including its structure, sequence and organization,
+    constitutes the valuable trade secrets of Broadcom, and you shall use
+    all reasonable efforts to protect the confidentiality thereof, and to
+    use this information only in connection with your use of Broadcom
+    integrated circuit products.
+
+2. TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE SOFTWARE IS PROVIDED "AS IS"
+    AND WITH ALL FAULTS AND BROADCOM MAKES NO PROMISES, REPRESENTATIONS OR
+    WARRANTIES, EITHER EXPRESS, IMPLIED, STATUTORY, OR OTHERWISE, WITH
+    RESPECT TO THE SOFTWARE.  BROADCOM SPECIFICALLY DISCLAIMS ANY AND
+    ALL IMPLIED WARRANTIES OF TITLE, MERCHANTABILITY, NONINFRINGEMENT,
+    FITNESS FOR A PARTICULAR PURPOSE, LACK OF VIRUSES, ACCURACY OR
+    COMPLETENESS, QUIET ENJOYMENT, QUIET POSSESSION OR CORRESPONDENCE
+    TO DESCRIPTION. YOU ASSUME THE ENTIRE RISK ARISING OUT OF USE OR
+    PERFORMANCE OF THE SOFTWARE.
+
+3. TO THE MAXIMUM EXTENT PERMITTED BY LAW, IN NO EVENT SHALL BROADCOM OR
+    ITS LICENSORS BE LIABLE FOR (i) CONSEQUENTIAL, INCIDENTAL, SPECIAL,
+    INDIRECT, OR EXEMPLARY DAMAGES WHATSOEVER ARISING OUT OF OR IN ANY
+    WAY RELATING TO YOUR USE OF OR INABILITY TO USE THE SOFTWARE EVEN
+    IF BROADCOM HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES;
+    OR (ii) ANY AMOUNT IN EXCESS OF THE AMOUNT ACTUALLY PAID FOR THE
+    SOFTWARE ITSELF OR U.S. $1, WHICHEVER IS GREATER. THESE LIMITATIONS
+    SHALL APPLY NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY
+    LIMITED REMEDY.
+:>
+*/
+#ifndef _BCMOLT_FIRMWARE_ENVELOPE_H_
+#define _BCMOLT_FIRMWARE_ENVELOPE_H_
+
+#include <bcmos_system.h>
+
+#define BCMOLT_FIRMWARE_ENVELOPE_DESC_MAX_SIZE 128
+#define BCMOLT_FIRMWARE_ENVELOPE_TIME_ZONE_SIZE 7
+#define BCMOLT_FIRMWARE_ENVELOPE_MD5_CHECKSUM_SIZE 16
+
+/* Normalized form of a firmware revision for comparison purposes. */
+#define DEVICE_MGMT_REVISION_RELEASE_MAJOR_ID_SHIFT 24
+#define DEVICE_MGMT_REVISION_RELEASE_MINOR_ID_SHIFT 16
+#define DEVICE_MGMT_REVISION_RELEASE_REVISION_ID_SHIFT 8
+#define DEVICE_MGMT_REVISION_MODEL_ID_SHIFT 0
+
+#define BCMOLT_FIRMWARE_ENVELOPE_NORMALIZE(rev_a) \
+    (((rev_a)->release_major_id << DEVICE_MGMT_REVISION_RELEASE_MAJOR_ID_SHIFT) | \
+    ((rev_a)->release_minor_id << DEVICE_MGMT_REVISION_RELEASE_MINOR_ID_SHIFT) | \
+    ((rev_a)->release_revision_id << DEVICE_MGMT_REVISION_RELEASE_REVISION_ID_SHIFT) | \
+    ((rev_a)->model_id << DEVICE_MGMT_REVISION_MODEL_ID_SHIFT))
+
+typedef struct __PACKED_ATTR_START__
+{
+    uint8_t release_major_id;
+    uint8_t release_minor_id;
+    uint8_t release_revision_id;
+    uint32_t model_id;
+} __PACKED_ATTR_END__ bcmolt_firmware_envelope_revision;
+
+typedef struct __PACKED_ATTR_START__
+{
+    uint8_t envelope_revision; /* The envelope itself can be changed over time, so this explains why we need an envelope revision field. */
+    bcmolt_firmware_envelope_revision revision; /* Revision information */
+    uint32_t block_issu_enforce; /* Every time a change in the code cannot be supported in ISSU and requires a regular upgrade (e.g.: SGB/SERDES firmware upgrade), this integer number will 
+                                  * be incremented. If revision validation function detects a change in this integer between two revisions, then it will block ISSU. */
+    uint32_t p4_change_set; /* This is purely informative field that should have no impact on validation. */
+    uint32_t build_time; /* This is purely informative field that should have no impact on validation. It contains the date/time of the image itself, expressed as seconds since the EPOCH. */
+    char build_time_zone[BCMOLT_FIRMWARE_ENVELOPE_TIME_ZONE_SIZE]; /* This is purely informative field that should have no impact on validation. It goes along with build time option and
+                                                                    * provides time zone information, as the embedded side does not know anything about time zone (without that, the build
+                                                                    * time converted to a string will always yield GMT time, not local time). */
+    uint8_t desc[BCMOLT_FIRMWARE_ENVELOPE_DESC_MAX_SIZE]; /* This is purely informative field that should have no impact on validation. */
+    uint8_t md5_checksum[BCMOLT_FIRMWARE_ENVELOPE_MD5_CHECKSUM_SIZE]; /* The MD5 checksum should be applied on the image itself, not on the envelope. This may be redundant because we
+                                                                       * automatically do CRC inherently as part of image transfer mechanism. However, this may have some future use. */
+    uint32_t image_len; /* The size in bytes of the image itself, not with the envelope. 4 bytes should be big enough to accommodate image length up to 4GB, which is far beyond what we
+                         * really need. */
+} __PACKED_ATTR_END__ bcmolt_firmware_envelope;
+
+#endif
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_math.h b/bcm68620_release/release/host_driver/utils/bcmolt_math.h
new file mode 100644
index 0000000..fb52a00
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_math.h
@@ -0,0 +1,71 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#ifndef _BCMOLT_MATH_H_
+#define _BCMOLT_MATH_H_
+
+#include <math.h>
+
+#define ROUND_U32(size_in_bytes) ((uint32_t)((size_in_bytes) + 0.5))
+#define CEIL_U32(size_in_bytes) (((size_in_bytes)-(uint32_t)(size_in_bytes)) > 0 ? ((uint32_t)(size_in_bytes)+1) : (uint32_t)(size_in_bytes))
+#define SQUARE(x) ((x) * (x))
+#define PERCENT(percent, x) (((float)(percent) * (x)) / 100)
+
+/*
+ * Unit Conversion
+ */
+#define BITS_TO_BYTES(bits) ((bits) >> 3)
+#define BYTES_TO_BITS(bytes) ((bytes) << 3)
+
+/* Quantization */
+
+/*
+ * VAL_TO_BIN classifies the value of val to the proper bin
+ * val - a value in the range [0, maxval]
+ * bin - a value in the range [0, bins-1] (result of macro)
+ */
+#define VAL_TO_BIN(val, maxval, bins) ((val) < (maxval) ? ((val) * (bins)) / (maxval) : (bins) - 1)
+
+/* If a value is in a certain bin, it is in the range [min_bin_val, max_bin_val]
+ * min_bin_val - minimum value that belongs to bin
+ * max_bin_val - maximum value that belongs to bin
+ */
+#define BIN_TO_MIN_BIN_VAL(bin, maxval, bins) ((bin) * ((double)(maxval) / (bins)))
+#define BIN_TO_MAX_BIN_VAL(bin, maxval, bins) (((bin) + 1) * ((double)(maxval) / (bins)))
+
+#define GET_MASK(width)             ((1 << (width)) - 1)
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#define MAX3(a, b, c) MAX(MAX(a, b), c)
+#define MIN3(a, b, c) MIN(MIN(a, b), c)
+
+#define CEILING(a, b)   (((a) + ((b) - 1)) / (b))
+
+#endif /* _BCMOLT_MATH_H_ */
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_module.h b/bcm68620_release/release/host_driver/utils/bcmolt_module.h
new file mode 100644
index 0000000..ad513e9
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_module.h
@@ -0,0 +1,52 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#ifndef _BCMOLT_MODULE_H_
+#define _BCMOLT_MODULE_H_
+
+#include <bcmos_system.h>
+#include <bcmolt_model_types.h>
+#include <bcm_dev_log.h>
+
+/* The following structure can be used by probably all modules in our system. */
+typedef struct
+{
+    bcmos_task task;
+    bcmos_bool is_enabled;
+    char task_name[MAX_TASK_NAME_SIZE];
+    dev_log_id log_id;
+    bcmolt_pon_ni pon_id;
+    char msg_queue_name[MAX_MSG_QUEUE_NAME_SIZE];
+    bcmos_msg_pool msg_pool;
+    bcmos_module_id module_id;
+    void *context;
+} bcmolt_module_gen_params;
+
+#endif
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_string.c b/bcm68620_release/release/host_driver/utils/bcmolt_string.c
new file mode 100644
index 0000000..a10fa20
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_string.c
@@ -0,0 +1,102 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#include "bcmolt_string.h"
+#include "bcmolt_math.h"
+
+struct bcmolt_string
+{
+    char *str;
+    uint32_t max_len;
+    char *curr;
+    int32_t remaining;
+};
+
+int bcmolt_string_copy(bcmolt_string *str, const char *buf, uint32_t size)
+{
+    int to_copy = MIN(size, str->remaining);
+    memcpy(str->curr, buf, to_copy);
+    str->remaining -= to_copy;
+    str->curr += to_copy;
+    str->curr[0] = '\0';
+    return to_copy;
+}
+
+int bcmolt_string_append(bcmolt_string *str, const char *fmt, ...)
+{
+    int n;
+    va_list args;
+
+    va_start(args, fmt);
+    n = vsnprintf(str->curr, str->remaining, fmt, args);
+    va_end(args);
+    if (n > 0)
+    {
+        if (n > str->remaining)
+        {
+            n = str->remaining;
+        }
+        str->remaining -= n;
+        str->curr += n;
+    }
+
+    return n;
+}
+
+const char *bcmolt_string_get(bcmolt_string *str)
+{
+    return str->str;
+}
+
+void bcmolt_string_reset(bcmolt_string *str)
+{
+    str->str[0] = '\0';
+    str->curr = str->str;
+    str->remaining = str->max_len;
+}
+
+bcmos_errno bcmolt_string_create(bcmolt_string **str, uint32_t max_len)
+{
+    *str = bcmos_calloc(sizeof(bcmolt_string) + max_len + 1);
+    if (*str != NULL)
+    {
+        (*str)->str = (char*)((*str) + 1);
+        (*str)->max_len = max_len;
+        bcmolt_string_reset(*str);
+        return BCM_ERR_OK;
+    }
+
+    return BCM_ERR_NOMEM;
+}
+
+void bcmolt_string_destroy(bcmolt_string *str)
+{
+    bcmos_free(str);
+}
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_string.h b/bcm68620_release/release/host_driver/utils/bcmolt_string.h
new file mode 100644
index 0000000..01fcaa2
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_string.h
@@ -0,0 +1,49 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#ifndef _BCMOLT_STRING_H_
+#define _BCMOLT_STRING_H_
+
+#include "bcmos_system.h"
+
+typedef struct bcmolt_string bcmolt_string;
+
+int bcmolt_string_copy(bcmolt_string *str, const char *buf, uint32_t size);
+
+int bcmolt_string_append(bcmolt_string *str, const char *fmt, ...);
+
+const char *bcmolt_string_get(bcmolt_string *str);
+
+void bcmolt_string_reset(bcmolt_string *str);
+
+bcmos_errno bcmolt_string_create(bcmolt_string **str, uint32_t max_len);
+
+void bcmolt_string_destroy(bcmolt_string *str);
+
+#endif /* _BCMOLT_STRING_H_ */
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_utils.c b/bcm68620_release/release/host_driver/utils/bcmolt_utils.c
new file mode 100644
index 0000000..b8a8994
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_utils.c
@@ -0,0 +1,204 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#include "bcmolt_utils.h"
+
+/* HexPrint a single line */
+#define BYTES_IN_LINE 16
+
+#define b2a(c)  (isprint(c)?c:'.')
+
+static void _hexprint1(bcmos_msg_print_cb print_cb, void *context, uint16_t o, const uint8_t *p_data, uint16_t count, const char *indent)
+{
+    int i;
+
+    if (indent)
+        print_cb(context, "%s", indent);
+
+    print_cb(context, "%04x: ", o);
+    for (i=0; i<count; i++)
+    {
+        print_cb(context, "%02x", p_data[i]);
+        if (!((i+1)%4))
+            print_cb(context, " ");
+    }
+    for (; i<BYTES_IN_LINE; i++)
+    {
+        if (!((i+1)%4))
+            print_cb(context, "   ");
+        else
+            print_cb(context, "  ");
+    }
+    for (i=0; i<count; i++)
+        print_cb(context, "%c", b2a(p_data[i]));
+    print_cb(context, "\n");
+}
+
+void bcmos_hexdump(bcmos_msg_print_cb print_cb, void *context, const void *buffer, uint32_t offset, uint32_t count, const char *indent)
+{
+    const uint8_t *p_data = buffer;
+    uint16_t n;
+
+    while (count)
+    {
+        n = (count > BYTES_IN_LINE) ? BYTES_IN_LINE : count;
+        _hexprint1(print_cb, context, offset, p_data, n, indent);
+        count -= n;
+        p_data += n;
+        offset += n;
+    }
+}
+
+void bcmos_hexdump_one_line(const char *funcname,     /* __FUNCTION__ */
+    uint32_t lineno,       /* __LINE__ */
+    bcmos_msg_print_cb print_cb,
+    void *context,
+    const void *buffer, /* start of memory region to dump */
+    uint32_t start_offset, /* start offset into the region */
+    uint32_t byte_count, /* number of bytes in region to dump */
+    const char *prefix, /* optional prefix string */
+    const char *suffix) /* optional suffix string */
+{
+    const uint8_t *p_data = buffer;
+    uint32_t data_offset = start_offset;
+    size_t max_buf_size = 8000; /* room enough to dump ~2600 bytes with shortish prefixes/suffixes */
+    char *out_buf = bcmos_calloc(max_buf_size);
+    size_t out_buf_offset = 0;
+    uint32_t tmp_num_chars = 0;
+
+    BUG_UNLESS(out_buf);
+
+    memset(out_buf, 0, max_buf_size);
+
+    if (prefix)
+    {
+        tmp_num_chars = snprintf(out_buf + out_buf_offset, /* out_buf start offset */
+            max_buf_size - out_buf_offset, /* remaining space in out_buf */
+            "\n%40s:%-5u  %s", funcname, lineno, prefix);
+    }
+    else
+    {
+        tmp_num_chars = snprintf(out_buf + out_buf_offset, /* out_buf start offset */
+            max_buf_size - out_buf_offset, /* remaining space in out_buf */
+            "\n");
+    }
+    out_buf_offset += tmp_num_chars;
+
+    while ((data_offset < (start_offset + byte_count)) && (out_buf_offset < max_buf_size))
+    {
+        tmp_num_chars = snprintf(out_buf + out_buf_offset, /* out_buf start offset */
+            max_buf_size - out_buf_offset, /* remaining space in out_buf */
+            "%02x ",
+            p_data[data_offset++]); /* byte to dump */
+        BUG_UNLESS(3 == tmp_num_chars);
+        out_buf_offset += tmp_num_chars;
+    }
+
+    if (tmp_num_chars < max_buf_size)
+    {
+        if (suffix)
+        {
+            tmp_num_chars = snprintf(out_buf + out_buf_offset, /* out_buf start offset */
+                max_buf_size - out_buf_offset, /* remaining space in out_buf */
+                "%s", suffix);
+        }
+        else
+        {
+            tmp_num_chars = snprintf(out_buf + out_buf_offset, /* out_buf start offset */
+                max_buf_size - out_buf_offset, /* remaining space in out_buf */
+                "\n");
+        }
+        out_buf_offset += tmp_num_chars;
+        BUG_UNLESS(out_buf_offset < max_buf_size);
+    }
+
+    print_cb(context, "%s", out_buf);
+    bcmos_free(out_buf);
+}
+
+static uint32_t eth_crc32_tab[] =
+{
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+    0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+    0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+    0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+    0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+    0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+    0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+    0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+    0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+    0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+    0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+    0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+    0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+    0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+    0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+    0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+    0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+    0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+};
+
+uint32_t eth_calc_crc32(uint32_t crc, const void *buf, size_t size)
+{
+    const uint8_t *p;
+
+    p = buf;
+    crc = crc ^ ~0U;
+
+    while (size--)
+        crc = eth_crc32_tab[(crc ^ *p++) & 0xFF] ^ (crc >> 8);
+
+    return crc ^ ~0U;
+}
+
diff --git a/bcm68620_release/release/host_driver/utils/bcmolt_utils.h b/bcm68620_release/release/host_driver/utils/bcmolt_utils.h
new file mode 100644
index 0000000..b8a5a2d
--- /dev/null
+++ b/bcm68620_release/release/host_driver/utils/bcmolt_utils.h
@@ -0,0 +1,134 @@
+/*
+<:copyright-BRCM:2016:DUAL/GPL:standard
+
+   Broadcom Proprietary and Confidential.(c) 2016 Broadcom
+   All Rights Reserved
+
+Unless you and Broadcom execute a separate written software license
+agreement governing use of this software, this software is licensed
+to you under the terms of the GNU General Public License version 2
+(the "GPL"), available at http://www.broadcom.com/licenses/GPLv2.php,
+with the following added to such license:
+
+   As a special exception, the copyright holders of this software give
+   you permission to link this software with independent modules, and
+   to copy and distribute the resulting executable under terms of your
+   choice, provided that you also meet, for each linked independent
+   module, the terms and conditions of the license of that module.
+   An independent module is a module which is not derived from this
+   software.  The special exception does not apply to any modifications
+   of the software.
+
+Not withstanding the above, under no circumstances may you combine
+this software in any way with any other Broadcom software provided
+under a license other than the GPL, without Broadcom's express prior
+written consent.
+
+:>
+ */
+
+#ifndef _BCMOLT_UTILS_H_
+#define _BCMOLT_UTILS_H_
+
+#include "bcmos_system.h"
+
+#define BCMOS_MACADDR_FMT_STR "%02X:%02X:%02X:%02X:%02X:%02X"
+#define BCMOS_MACADDR_PARAMS(mac) (mac)->u8[0],(mac)->u8[1],(mac)->u8[2],(mac)->u8[3],(mac)->u8[4],(mac)->u8[5]
+
+#define MAC_STR_LEN 18
+
+#define BYTES_IN_MEGABYTE(bytes) ((bytes) / (1024 * 1024))
+
+static inline char *bcmos_mac_2_str(const bcmos_mac_address *mac, char *buf)
+{
+    snprintf(buf, MAC_STR_LEN, BCMOS_MACADDR_FMT_STR, BCMOS_MACADDR_PARAMS(mac));
+    return buf;
+}
+
+/** Swap a byte string of any length.
+ *
+ * \param[in]   ptr     pointer to a memory space.
+ * \param[in]   len     length
+ * \note
+ *      {0, 1, 2, 3} becomes {3, 2, 1, 0}
+ */
+static inline void bcmos_swap_bytes_in_place(uint8_t *ptr, uint32_t len)
+{
+    int  ii;
+    char tmp;
+
+    for (ii = 0; ii < (len / 2); ii++)
+    {
+        tmp = ptr[len - ii - 1];
+        ptr[len - ii - 1] = ptr[ii];
+        ptr[ii] = tmp;
+    }
+}
+
+/** Swap a byte string of any length.
+ *
+ * \param[out]      dst     pointer to a memory space for the swapped bytes.
+ * \param[in]       src     pointer to a memory space for bytes to be swapped.
+ * \param[in]       len     length in bytes
+ * \note
+ *      {0, 1, 2, 3} becomes {3, 2, 1, 0}
+ */
+static inline void bcmos_swap_bytes(uint8_t *dst, const uint8_t *src, const uint32_t len)
+{
+    int  ii;
+
+    for (ii = 0; ii < len; ii++)
+    {
+        dst[ii] = src[len - ii - 1];
+    }
+}
+
+/** Copy bits from a given range of the source to a different range of the
+ *  destination
+ *
+ * \param[in]   dst         destination value to be merged to
+ * \param[in]   dst_hi      high bit position
+ * \param[in]   dst_lo      low bit position
+ * \param[in]   src         source value to copy the bits from
+ * \param[in]   src_hi      high bit position
+ * \param[in]   src_lo      low bit position
+ *
+ * \return      destination value
+ */
+static inline uint32_t bcmos_bits_copy_u32(uint32_t dst, uint8_t dst_hi, uint8_t dst_lo,
+    uint32_t src, uint8_t src_hi, uint8_t src_lo)
+{
+    dst &= (~(((1 << ((dst_hi - dst_lo) + 1)) - 1) << dst_lo));
+    src &= (((1 << ((src_hi - src_lo) + 1)) - 1) << src_lo);
+    dst |= ((dst_lo >= src_lo)? (src << (dst_lo - src_lo)): (src >> (src_lo - dst_lo)));
+    return dst;
+}
+
+/* network to host on unaligned array of uint32_t elements. Treat pointer p as a pointer to an array of uint32_t elements. Get element i.  */
+#define N2H32(p, i) ((((const uint8_t *)(p))[(i) * 4]<<24) | (((const uint8_t *)(p))[(i) * 4+1]<<16) | (((const uint8_t *)(p))[(i) * 4+2]<<8) | (((const uint8_t *)(p))[(i) * 4+3]))
+/* network to host on unaligned array of uint16_t elements. Treat pointer p as a pointer to an array of uint16_t elements. Get element i. */
+#define N2H16(p, i) ((((const uint8_t *)(p))[(i) * 2]<<8) | (((const uint8_t *)(p))[(i) * 2+1]))
+/* network to host on unaligned array of uint8_t elements. Treat pointer p as a pointer to an array of uint8_t elements. Get element i. */
+#define N2H8(p, i) (((const uint8_t *)(p))[(i)])
+
+/* For internal use by the following H2N* macros */
+#define H2N8(p, v)   *((uint8_t *)p) = (uint8_t)(v)
+/* host to network conversion of a uint16_t with support for non 16 bit aligned destination address. p is a (uint8_t *) destination pointer. v is a uint16_t value. v can be written to p even if p is unaligned to 16 bits. */
+#define H2N16(p, v)  (H2N8((p), (v) >> 8), H2N8(((uint8_t *)(p) + 1), (v)))
+/* host to network conversion of a uint32_t with support for non 32 bit aligned destination address. p is a (uint8_t *) destination pointer. v is a uint32_t value. v can be written to p even if p is unaligned to 32 bits. */
+#define H2N32(p, v)  (H2N16((p), (v) >> 16), H2N16(((uint8_t *)(p) + 2), (v)))
+
+#define NUM_ELEM(array)     (sizeof(array) / sizeof((array)[0]))
+
+typedef void (*bcmos_msg_print_cb)(void *context, const char *fmt, ...);
+
+void bcmos_hexdump(bcmos_msg_print_cb print_cb, void *context, const void *buffer, uint32_t offset, uint32_t count, const char *indent);
+void bcmos_hexdump_one_line(const char *funcname, uint32_t lineno, bcmos_msg_print_cb print_cb, void *context, const void *buffer, uint32_t offset, uint32_t count, const char *prefix,
+    const char *suffix);
+
+uint32_t eth_calc_crc32(uint32_t crc, const void *buf, size_t size);
+
+#define BCMOLT_TIME_STR_MAX_LEN 80
+
+#endif /* BCMOLT_UTILS_H */
+