diff --git a/bal_release/src/lib/libtopology/Makefile b/bal_release/src/lib/libtopology/Makefile
new file mode 100644
index 0000000..7507881
--- /dev/null
+++ b/bal_release/src/lib/libtopology/Makefile
@@ -0,0 +1,36 @@
+###############################################################################
+#
+#  <:copyright-BRCM:2016:DUAL/GPL:standard
+#  
+#     Copyright (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.
+#  
+#  :>
+#
+###############################################################################
+MOD_NAME = topology
+MOD_TYPE = lib
+MOD_DEPS = dev_log maple_sdk
+
+srcs = bcm_topo.c
+
diff --git a/bal_release/src/lib/libtopology/bcm_topo.c b/bal_release/src/lib/libtopology/bcm_topo.c
new file mode 100644
index 0000000..4b092a0
--- /dev/null
+++ b/bal_release/src/lib/libtopology/bcm_topo.c
@@ -0,0 +1,650 @@
+/******************************************************************************
+ *
+ *  <:copyright-BRCM:2016:DUAL/GPL:standard
+ *
+ *     Copyright (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 <bcm_dev_log.h>
+#include <bcmolt_math.h>
+#include "bcm_topo.h"
+
+#define BCM_TOPO_MAX_LINE_SIZE 256
+#define BCM_TOPO_MAX_NNI_DEVICES 1
+
+uint32_t g_max_nni_ports[BCM_TOPO_MAX_NNI_DEVICES] = {BCM_TOPO_MAX_NNI_PORTS};
+
+typedef struct bcm_topo_dev_context_t bcm_topo_dev_context_t;
+
+typedef struct
+{
+    bcm_topo_dev_context_t *dev; /* Back pointer to the physical device this PON belongs to */
+    bcmos_bool is_initialized;
+    uint32_t pon_id;
+    uint32_t logical_pon;
+    bcm_topo_pon_mode pon_mode;
+    uint32_t max_num_of_onus;
+    void *contexts[BCM_TOPO_PON_CONTEXT_ID__NUM_OF]; /* User context - 1 entry per user */
+} bcm_topo_pon_context_t;
+
+struct bcm_topo_dev_context_t
+{
+    bcm_topo_pon_mode pon_mode; /* Currently we do not allow more than one PON mode per device (e.g: GPONx8 + XGPONx4) */
+    bcmos_bool is_initialized;
+    uint32_t device_id;
+    uint32_t max_num_of_pons;
+    bcm_topo_pon_context_t pons[BCM_TOPO_MAX_NUM_OF_PONS_PER_DEV];
+};
+
+typedef struct
+{
+    bcmos_bool is_initialized;
+    bcm_topo_dev_context_t devs[BCM_TOPO_MAX_NUM_OF_DEVS];
+    bcm_topo_pon_context_t *logical_pon2physical_pon[BCM_TOPO_MAX_NUM_OF_LOGICAL_PONS];
+} bcm_topo_context_t;
+
+static bcm_topo_context_t bcm_topo_context;
+
+#ifdef ENABLE_LOG
+static dev_log_id topo_log_id = DEV_LOG_INVALID_ID;
+#endif
+
+static int2str_t pon_mode2str[] =
+{
+    {BCM_TOPO_PON_MODE_GPON, "gpon"},
+    {BCM_TOPO_PON_MODE_XGPON, "xgpon"},
+    {BCM_TOPO_PON_MODE_XGS, "xgs"},
+    {BCM_TOPO_PON_MODE_EPON_TDMA, "epon_tdma"},
+    {BCM_TOPO_PON_MODE_EPON_1G, "epon_1g"},
+    {BCM_TOPO_PON_MODE_EPON_10G, "epon_10g"},
+    {-1},
+};
+
+static int2int_t pon_mode2max_num_of_pons[] =
+{
+    {BCM_TOPO_PON_MODE_GPON, 16},
+    {BCM_TOPO_PON_MODE_XGPON, 8},
+    {BCM_TOPO_PON_MODE_XGS, 2},
+    {BCM_TOPO_PON_MODE_EPON_TDMA, 8},
+    {BCM_TOPO_PON_MODE_EPON_1G, 16},
+    {BCM_TOPO_PON_MODE_EPON_10G, 8},
+    {-1},
+};
+
+const char *bcm_topo_dev_get_pon_mode_str(bcmolt_devid device_id)
+{
+    return int2str(pon_mode2str, bcm_topo_context.devs[device_id].pon_mode);
+}
+
+int bcm_topo_dev_get_max_pon(bcmolt_devid device_id)
+{
+    return int2int(pon_mode2max_num_of_pons, bcm_topo_context.devs[device_id].pon_mode);
+}
+
+bcm_topo_pon_mode bcm_topo_pon_get_pon_mode(uint32_t pon)
+{
+    bcmolt_devid device_id;
+    uint32_t physical_pon;
+    bcmos_errno rc;
+
+    rc = bcm_topo_pon_get_logical2physical(pon, &device_id, &physical_pon);
+    if (rc != BCM_ERR_OK)
+        return BCM_TOPO_PON_MODE_INVALID;
+
+    return bcm_topo_context.devs[device_id].pons[physical_pon].pon_mode;
+}
+
+bcm_topo_pon_family bcm_topo_pon_get_pon_family(uint32_t pon)
+{
+    switch (bcm_topo_pon_get_pon_mode(pon))
+    {
+    case BCM_TOPO_PON_MODE_GPON:
+    case BCM_TOPO_PON_MODE_XGPON:
+    case BCM_TOPO_PON_MODE_XGS:
+        return BCM_TOPO_PON_FAMILY_GPON;
+    case BCM_TOPO_PON_MODE_EPON_TDMA:
+    case BCM_TOPO_PON_MODE_EPON_1G:
+    case BCM_TOPO_PON_MODE_EPON_10G:
+        return BCM_TOPO_PON_FAMILY_EPON;
+    default:
+        return BCM_TOPO_PON_FAMILY_INVALID;
+    }
+}
+
+bcm_topo_pon_sub_family bcm_topo_pon_get_pon_sub_family(uint32_t pon)
+{
+    switch (bcm_topo_pon_get_pon_mode(pon))
+    {
+    case BCM_TOPO_PON_MODE_GPON:
+        return BCM_TOPO_PON_SUB_FAMILY_GPON;
+    case BCM_TOPO_PON_MODE_XGPON:
+    case BCM_TOPO_PON_MODE_XGS:
+        return BCM_TOPO_PON_SUB_FAMILY_XGPON;
+    case BCM_TOPO_PON_MODE_EPON_TDMA:
+    case BCM_TOPO_PON_MODE_EPON_1G:
+    case BCM_TOPO_PON_MODE_EPON_10G:
+        return BCM_TOPO_PON_SUB_FAMILY_EPON;
+    default:
+        return BCM_TOPO_PON_SUB_FAMILY_INVALID;
+    }
+}
+
+uint32_t bcm_topo_pon_get_max_num_of_onus(uint32_t pon)
+{
+    bcmolt_devid device_id;
+    uint32_t physical_pon;
+    bcmos_errno rc;
+
+    rc = bcm_topo_pon_get_logical2physical(pon, &device_id, &physical_pon);
+    if (rc != BCM_ERR_OK)
+        return BCM_TOPO_ERR_INVALID;
+
+    return bcm_topo_context.devs[device_id].pons[physical_pon].max_num_of_onus;
+}
+
+bcmos_bool bcm_topo_pon_is_valid(uint32_t pon)
+{
+    bcmolt_devid device_id;
+    uint32_t physical_pon;
+
+    if (bcm_topo_pon_get_logical2physical(pon, &device_id, &physical_pon) != BCM_ERR_OK)
+        return BCMOS_FALSE;
+
+    return BCMOS_TRUE;
+}
+
+bcmolt_devid bcm_topo_dev_get_next(bcmolt_devid device_id)
+{
+    if (device_id == BCM_TOPO_DEV_INVALID)
+        device_id = 0;
+    else
+        device_id++;
+
+    for (; device_id < BCM_TOPO_MAX_NUM_OF_DEVS && !bcm_topo_context.devs[device_id].is_initialized; device_id++);
+
+    return device_id == BCM_TOPO_MAX_NUM_OF_DEVS ? BCM_TOPO_DEV_INVALID : device_id;
+}
+
+uint32_t bcm_topo_pon_get_next(bcmolt_devid device_id, uint32_t pon)
+{
+    uint32_t physical_pon;
+    bcmos_errno rc;
+
+    if (device_id >= BCM_TOPO_MAX_NUM_OF_DEVS)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Device ID must be in the range 0 .. %u\n", BCM_TOPO_MAX_NUM_OF_DEVS - 1);
+        return BCM_TOPO_PON_INVALID;
+    }
+
+    if (pon == BCM_TOPO_PON_INVALID)
+        physical_pon = 0;
+    else
+    {
+        bcmolt_devid dummy;
+
+        rc = bcm_topo_pon_get_logical2physical(pon, &dummy, &physical_pon);
+        if (rc != BCM_ERR_OK)
+        {
+            return BCM_TOPO_PON_INVALID;
+        }
+        else
+        {
+            physical_pon++;
+        }
+    }
+
+    if (physical_pon < bcm_topo_context.devs[device_id].max_num_of_pons)
+    {
+        rc = bcm_topo_pon_get_physical2logical(device_id, physical_pon, &pon);
+        if (rc != BCM_ERR_OK)
+        {
+            return BCM_TOPO_PON_INVALID;
+        }
+        else
+        {
+            return pon;
+        }
+    }
+
+    return BCM_TOPO_PON_INVALID;
+}
+
+bcmos_errno bcm_topo_pon_get_logical2physical(uint32_t logical_pon, bcmolt_devid *device_id, uint32_t *physical_pon)
+{
+    if (logical_pon >= BCM_TOPO_MAX_NUM_OF_LOGICAL_PONS)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Logical PON ID must be in the range 0 .. %u\n", BCM_TOPO_MAX_NUM_OF_LOGICAL_PONS - 1);
+        return BCM_ERR_RANGE;
+    }
+
+    if (!bcm_topo_context.logical_pon2physical_pon[logical_pon])
+    {
+        BCM_LOG(ERROR, topo_log_id, "Logical PON=%u was not associated with a physical PON\n", logical_pon);
+        return BCM_ERR_RANGE;
+    }
+
+    *physical_pon = bcm_topo_context.logical_pon2physical_pon[logical_pon]->pon_id;
+    *device_id = bcm_topo_context.logical_pon2physical_pon[logical_pon]->dev->device_id;
+
+    return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_topo_pon_get_physical2logical(bcmolt_devid device_id, uint32_t physical_pon, uint32_t *logical_pon)
+{
+    if (device_id >= BCM_TOPO_MAX_NUM_OF_DEVS)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Device ID must be in the range 0 .. %u\n", BCM_TOPO_MAX_NUM_OF_DEVS - 1);
+        return BCM_ERR_RANGE;
+    }
+
+    if (physical_pon >= bcm_topo_context.devs[device_id].max_num_of_pons)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Physical PON ID must be in the range 0 .. %u\n", bcm_topo_context.devs[device_id].max_num_of_pons - 1);
+        return BCM_ERR_RANGE;
+    }
+
+    if (bcm_topo_context.devs[device_id].pons[physical_pon].logical_pon == BCM_TOPO_PON_INVALID)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Physical PON=%u on device=%u was not associated with a logical PON\n", physical_pon, device_id);
+        return BCM_ERR_RANGE;
+    }
+
+    *logical_pon = bcm_topo_context.devs[device_id].pons[physical_pon].logical_pon;
+
+    return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_topo_pon_set_context(uint32_t pon, bcm_topo_pon_context_id pon_context_id, void *context)
+{
+    bcmolt_devid device_id;
+    uint32_t physical_pon;
+    bcmos_errno rc;
+
+    if (pon_context_id >= BCM_TOPO_PON_CONTEXT_ID__NUM_OF)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Invalid PON context ID\n");
+        return BCM_ERR_RANGE;
+    }
+
+    rc = bcm_topo_pon_get_logical2physical(pon, &device_id, &physical_pon);
+    if (rc != BCM_ERR_OK)
+        return rc;
+
+    bcm_topo_context.devs[device_id].pons[physical_pon].contexts[pon_context_id] = context;
+
+    return BCM_ERR_OK;
+}
+
+void *bcm_topo_pon_get_context(uint32_t pon, bcm_topo_pon_context_id pon_context_id)
+{
+    bcmolt_devid device_id;
+    uint32_t physical_pon;
+    bcmos_errno rc;
+
+    if (pon_context_id >= BCM_TOPO_PON_CONTEXT_ID__NUM_OF)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Invalid PON context ID\n");
+        return NULL;
+    }
+
+    rc = bcm_topo_pon_get_logical2physical(pon, &device_id, &physical_pon);
+    if (rc != BCM_ERR_OK)
+        return NULL;
+
+    return bcm_topo_context.devs[device_id].pons[physical_pon].contexts[pon_context_id];
+}
+
+static void bcm_topo_init_context(void)
+{
+    uint32_t device_id;
+
+    for (device_id = 0; device_id < BCM_TOPO_MAX_NUM_OF_DEVS; device_id++)
+    {
+        bcm_topo_dev_context_t *dev;
+        uint32_t pon_id;
+
+        dev = &bcm_topo_context.devs[device_id];
+        dev->device_id = device_id;
+        dev->pon_mode = BCM_TOPO_PON_MODE_INVALID;
+        for (pon_id = 0; pon_id < BCM_TOPO_MAX_NUM_OF_PONS_PER_DEV; pon_id++)
+        {
+            bcm_topo_pon_context_t *pon;
+
+            pon = &dev->pons[pon_id];
+            pon->dev = dev;
+            pon->pon_id = pon_id;
+            pon->pon_mode = BCM_TOPO_PON_MODE_INVALID;
+            pon->logical_pon = BCM_TOPO_PON_INVALID;
+        }
+    }
+}
+
+static bcmos_errno bcm_topo_init_line_parse(const char *line, const char *filename, uint32_t line_num, bcmos_bool *is_skipped, uint32_t *logical_pon, bcm_topo_pon_mode *pon_mode,
+    uint32_t *device_id, uint32_t *physical_pon)
+{
+    int rc;
+    char logical_pon_str[BCM_TOPO_MAX_LINE_SIZE];
+    char pon_mode_str[BCM_TOPO_MAX_LINE_SIZE];
+    char device_id_str[BCM_TOPO_MAX_LINE_SIZE];
+    char physical_pon_str[BCM_TOPO_MAX_LINE_SIZE];
+    int2str_t *p;
+
+    /* Skip blank lines and comments. */
+    if (!*line || *line == '\n' || *line == '#')
+    {
+        *is_skipped = BCMOS_TRUE;
+        return BCM_ERR_OK;
+    }
+
+    *is_skipped = BCMOS_FALSE;
+
+    /* Read the tokens separated by commas. */
+    rc = sscanf(line, "%[^,],%*[ ]%[^,],%[^,],%[^\n]", logical_pon_str, pon_mode_str, device_id_str, physical_pon_str);
+    if (rc < 4)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Error parsing line %s:%u (rc=%u)\n", filename, line_num, rc);
+        return BCM_ERR_PARSE;
+    }
+
+    if (sscanf(logical_pon_str, "%u", logical_pon) < 1)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Error parsing line %s:%u (rc=%u)\n", filename, line_num, rc);
+        return BCM_ERR_PARSE;
+    }
+
+    if (sscanf(device_id_str, "%u", device_id) < 1)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Error parsing line %s:%u (rc=%u)\n", filename, line_num, rc);
+        return BCM_ERR_PARSE;
+    }
+
+    if (sscanf(physical_pon_str, "%u", physical_pon) < 1)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Error parsing line %s:%u (rc=%u)\n", filename, line_num, rc);
+        return BCM_ERR_PARSE;
+    }
+
+    BCM_LOG(INFO, topo_log_id, "Map Logical PON ID=%u -> (Physical Device ID=%u, Physical Pon ID=%u, PON mode='%s')\n", *logical_pon, *device_id, *physical_pon, pon_mode_str);
+
+    for (p = pon_mode2str; p->from != -1 && strcmp(pon_mode_str, p->to); p++);
+
+    if (p->from == -1)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Error parsing PON mode at %s:%u\n", filename, line_num);
+        return BCM_ERR_PARSE;
+    }
+
+    *pon_mode = p->from;
+
+    return BCM_ERR_OK;
+}
+
+static void bcm_topo_init_dev(bcm_topo_dev_context_t *dev, bcm_topo_pon_mode pon_mode)
+{
+    dev->pon_mode = pon_mode;
+    dev->max_num_of_pons = int2int(pon_mode2max_num_of_pons, pon_mode);
+}
+
+static void bcm_topo_init_pon(bcm_topo_pon_context_t *pon, bcm_topo_pon_mode pon_mode)
+{
+    pon->pon_mode = pon_mode;
+    switch (pon_mode)
+    {
+    case BCM_TOPO_PON_MODE_GPON:
+        pon->max_num_of_onus = 128;
+        break;
+    case BCM_TOPO_PON_MODE_XGPON:
+    case BCM_TOPO_PON_MODE_XGS:
+        pon->max_num_of_onus = 256;
+        break;
+    case BCM_TOPO_PON_MODE_EPON_TDMA:
+    case BCM_TOPO_PON_MODE_EPON_1G:
+    case BCM_TOPO_PON_MODE_EPON_10G:
+        pon->max_num_of_onus = 0; /* There is no "ONU" in EPON, but LLIDs. */
+        break;
+    default:
+        break;
+    }
+}
+
+static bcmos_errno bcm_topo_init_by_file(FILE *fp, const char *filename)
+{
+    char line[BCM_TOPO_MAX_LINE_SIZE];
+    uint32_t line_num;
+
+    /* Read next line. */
+    line_num = 1;
+    while (fgets(line, sizeof(line), fp))
+    {
+        bcmos_bool is_skipped;
+        uint32_t logical_pon, device_id, physical_pon;
+        bcm_topo_pon_mode pon_mode;
+        bcm_topo_dev_context_t *dev;
+        bcm_topo_pon_context_t *pon;
+
+        if (bcm_topo_init_line_parse(line, filename, line_num, &is_skipped, &logical_pon, &pon_mode, &device_id, &physical_pon) != BCM_ERR_OK)
+            return BCM_ERR_PARSE;
+
+        if (is_skipped)
+        {
+            line_num++;
+            continue;
+        }
+
+        if (logical_pon >= BCM_TOPO_MAX_NUM_OF_LOGICAL_PONS)
+        {
+            BCM_LOG(ERROR, topo_log_id, "Logical PON ID at %s:%u must be in the range 0 .. %u\n", filename, line_num, BCM_TOPO_MAX_NUM_OF_LOGICAL_PONS - 1);
+            return BCM_ERR_RANGE;
+        }
+
+        if (bcm_topo_context.logical_pon2physical_pon[logical_pon])
+        {
+            BCM_LOG(ERROR, topo_log_id, "Logical PON ID at %s:%u has already been set before\n", filename, line_num);
+            return BCM_ERR_ALREADY;
+        }
+
+        if (device_id >= BCM_TOPO_MAX_NUM_OF_DEVS)
+        {
+            BCM_LOG(ERROR, topo_log_id, "Physical device ID at %s:%u must be in the range 0 .. %u\n", filename, line_num, BCM_TOPO_MAX_NUM_OF_DEVS - 1);
+            return BCM_ERR_RANGE;
+        }
+
+        dev = &bcm_topo_context.devs[device_id];
+        if (!dev->is_initialized)
+        {
+            bcm_topo_init_dev(dev, pon_mode);
+            dev->is_initialized = BCMOS_TRUE;
+        }
+        else if (dev->pon_mode != pon_mode)
+        {
+            BCM_LOG(ERROR, topo_log_id, "PON mode at %s:%u conflicts with PON mode='%s' that has already been set for this device\n", filename, line_num,
+                int2str(pon_mode2str, dev->pon_mode));
+            return BCM_ERR_NOT_SUPPORTED;
+        }
+
+        if (physical_pon >= dev->max_num_of_pons)
+        {
+            BCM_LOG(ERROR, topo_log_id, "Physical PON ID at %s:%u must be in the range 0 .. %u\n", filename, line_num, dev->max_num_of_pons - 1);
+            return BCM_ERR_RANGE;
+        }
+
+        pon = &bcm_topo_context.devs[device_id].pons[physical_pon];
+        if (!pon->is_initialized)
+        {
+            bcm_topo_init_pon(pon, pon_mode);
+            pon->is_initialized = BCMOS_TRUE;
+        }
+        else
+        {
+            BCM_LOG(ERROR, topo_log_id, "Physical PON ID at %s:%u has already been set before\n", filename, line_num);
+            return BCM_ERR_ALREADY;
+        }
+
+        bcm_topo_context.logical_pon2physical_pon[logical_pon] = &bcm_topo_context.devs[device_id].pons[physical_pon];
+        bcm_topo_context.devs[device_id].pons[physical_pon].logical_pon = logical_pon;
+
+        line_num++;
+    }
+
+    return BCM_ERR_OK;
+}
+
+static bcmos_errno bcm_topo_init_by_args(bcm_topo_params *params)
+{
+    uint32_t device_id;
+    uint32_t max_num_of_pons_per_dev;
+
+    if (params->num_of_devs > BCM_TOPO_MAX_NUM_OF_DEVS)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Number of devices must be in the range 0 .. %u\n", BCM_TOPO_MAX_NUM_OF_DEVS);
+        return BCM_ERR_RANGE;
+    }
+
+    max_num_of_pons_per_dev = int2int(pon_mode2max_num_of_pons, params->pon_mode);
+
+    if (params->num_of_pons_per_dev > max_num_of_pons_per_dev)
+    {
+        BCM_LOG(ERROR, topo_log_id, "Number of PONs per device for PON mode '%s' must be in the range 0 .. %u\n", int2str(pon_mode2str, params->pon_mode), BCM_TOPO_MAX_NUM_OF_DEVS);
+        return BCM_ERR_RANGE;
+    }
+
+    for (device_id = 0; device_id < params->num_of_devs; device_id++)
+    {
+        uint32_t physical_pon;
+        bcm_topo_dev_context_t *dev;
+        bcm_topo_pon_context_t *pon;
+
+        dev = &bcm_topo_context.devs[device_id];
+        bcm_topo_init_dev(dev, params->pon_mode);
+        dev->is_initialized = BCMOS_TRUE;
+
+        for (physical_pon = 0; physical_pon < params->num_of_pons_per_dev; physical_pon++)
+        {
+            uint32_t logical_pon;
+
+            logical_pon = (device_id * params->num_of_pons_per_dev) + physical_pon;
+
+            BCM_LOG(INFO, topo_log_id, "Map Logical PON ID=%u -> (Physical Device ID=%u, Physical pon ID=%u, PON mode='%s')\n", logical_pon, device_id, physical_pon,
+                int2str(pon_mode2str, params->pon_mode));
+
+            pon = &bcm_topo_context.devs[device_id].pons[physical_pon];
+            bcm_topo_init_pon(pon, params->pon_mode);
+            pon->is_initialized = BCMOS_TRUE;
+
+            bcm_topo_context.logical_pon2physical_pon[logical_pon] = &bcm_topo_context.devs[device_id].pons[physical_pon];
+            bcm_topo_context.devs[device_id].pons[physical_pon].logical_pon = logical_pon;
+        }
+    }
+
+    return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_topo_init(bcm_topo_params *params, const char *topo_filename)
+{
+    bcmos_errno ret;
+    FILE *topo_fp;
+
+#ifdef ENABLE_LOG
+    if (topo_log_id == DEV_LOG_INVALID_ID)
+    {
+        topo_log_id = bcm_dev_log_id_register("TOPOLOGY", DEV_LOG_LEVEL_INFO, DEV_LOG_ID_TYPE_BOTH);
+        BUG_ON(topo_log_id == DEV_LOG_INVALID_ID);
+    }
+#endif
+
+    bcm_topo_init_context();
+
+    topo_fp = fopen(topo_filename, "r");
+    if (topo_fp)
+    {
+        BCM_LOG(INFO, topo_log_id, "Topology is taken from file\n");
+        ret = bcm_topo_init_by_file(topo_fp, topo_filename);
+        fclose(topo_fp);
+    }
+    else if (params)
+    {
+        BCM_LOG(INFO, topo_log_id, "Topology is taken from arguments\n");
+        ret = bcm_topo_init_by_args(params);
+    }
+    else
+    {
+        BCM_LOG(INFO, topo_log_id, "At least one of topo_fp and params must be specified and exist\n");
+        ret = BCM_ERR_PARM;
+    }
+
+    if (ret != BCM_ERR_OK)
+        goto exit;
+
+    bcm_topo_context.is_initialized = BCMOS_TRUE;
+
+    ret = BCM_ERR_OK;
+
+exit:
+    return ret;
+}
+
+bcmos_bool bcm_topo_is_initialized(void)
+{
+    return bcm_topo_context.is_initialized;
+}
+
+bcmos_bool bcm_topo_dev_set_max_nni(bcmolt_devid device_id, uint32_t num_nni_ports)
+{
+    if(device_id >= BCM_TOPO_MAX_NNI_DEVICES)
+    {
+        return BCM_ERR_PARM;
+    }
+    /* make sure the max number does not exceed the allocated resrouce */
+    if( num_nni_ports > BCM_TOPO_MAX_NNI_PORTS)
+    {
+        return BCM_ERR_PARM;
+    } 
+    g_max_nni_ports[device_id] = num_nni_ports;
+
+    return BCMOS_TRUE;
+}
+
+bcmos_bool bcm_topo_dev_get_max_nni(bcmolt_devid device_id, uint32_t *p_num_nni_ports)
+{
+    if(device_id >= BCM_TOPO_MAX_NNI_DEVICES)
+    {
+        return BCM_ERR_PARM;
+    }
+     *p_num_nni_ports = g_max_nni_ports[device_id];
+
+    return BCMOS_TRUE;
+}
+
+bcmos_bool bcm_topo_nni_is_valid(uint32_t nni)
+{
+
+    if (nni >= g_max_nni_ports[0])
+        return BCMOS_FALSE;
+
+    return BCMOS_TRUE;
+}
+
diff --git a/bal_release/src/lib/libtopology/bcm_topo.h b/bal_release/src/lib/libtopology/bcm_topo.h
new file mode 100644
index 0000000..9c6ec1c
--- /dev/null
+++ b/bal_release/src/lib/libtopology/bcm_topo.h
@@ -0,0 +1,270 @@
+/******************************************************************************
+ *
+ *  <:copyright-BRCM:2016:DUAL/GPL:standard
+ *
+ *     Copyright (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 _BCM_TOPO_H_
+#define _BCM_TOPO_H_
+
+#include <bcmolt_conv.h>
+#include <bcmos_system.h>
+#include <bcmolt_model_types.h>
+#include <bal_model_types.h>
+
+#define BCM_TOPO_DEV_INVALID UINT8_MAX
+#define BCM_TOPO_PON_INVALID UINT32_MAX
+#define BCM_TOPO_ERR_INVALID UINT32_MAX
+#define BCM_TOPO_MAX_NUM_OF_DEVS 8 /* Maxmimum of 8 devices per vOLT. */
+#define BCM_TOPO_MAX_NUM_OF_PONS_PER_DEV 16
+#define BCM_TOPO_MAX_NUM_OF_LOGICAL_PONS (BCM_TOPO_MAX_NUM_OF_DEVS * BCM_TOPO_MAX_NUM_OF_PONS_PER_DEV)
+
+#define BCM_TOPO_FOR_EACH_DEV(device_id) \
+    for (device_id = bcm_topo_dev_get_next(BCM_TOPO_DEV_INVALID); device_id != BCM_TOPO_DEV_INVALID; device_id = bcm_topo_dev_get_next(device_id))
+
+#define BCM_TOPO_DEV_FOR_EACH_PON(device_id, pon) \
+    for (pon = bcm_topo_pon_get_next(device_id, BCM_TOPO_PON_INVALID); pon != BCM_TOPO_PON_INVALID; pon = bcm_topo_pon_get_next(device_id, pon))
+
+#define BCM_TOPO_FOR_EACH_PON(device_id, pon) \
+    for (device_id = bcm_topo_dev_get_next(BCM_TOPO_DEV_INVALID); device_id != BCM_TOPO_DEV_INVALID; device_id = bcm_topo_dev_get_next(device_id)) \
+        BCM_TOPO_DEV_FOR_EACH_PON(device_id, pon)
+
+#define BCM_TOPO_FOR_EACH_ONU(pon, onu) \
+    for (onu = 0; onu < bcm_topo_pon_get_max_num_of_onus(pon); onu++)
+
+typedef enum
+{
+    BCM_TOPO_PON_MODE_GPON,
+    BCM_TOPO_PON_MODE_XGPON,
+    BCM_TOPO_PON_MODE_XGS,
+    BCM_TOPO_PON_MODE_EPON_TDMA,
+    BCM_TOPO_PON_MODE_EPON_1G,
+    BCM_TOPO_PON_MODE_EPON_10G,
+    BCM_TOPO_PON_MODE_INVALID,
+    BCM_TOPO_PON_MODE__NUM_OF,
+} bcm_topo_pon_mode;
+
+typedef enum
+{
+    BCM_TOPO_PON_FAMILY_GPON, /* GPON, XGPON, XGS, NGPON2 */
+    BCM_TOPO_PON_FAMILY_EPON,
+    BCM_TOPO_PON_FAMILY_INVALID,
+    BCM_TOPO_PON_FAMILY__NUM_OF,
+} bcm_topo_pon_family;
+
+typedef enum
+{
+    BCM_TOPO_PON_SUB_FAMILY_GPON, /* GPON only */
+    BCM_TOPO_PON_SUB_FAMILY_XGPON, /* XGPON, XGS, NGPON2 */
+    BCM_TOPO_PON_SUB_FAMILY_EPON,
+    BCM_TOPO_PON_SUB_FAMILY_INVALID,
+    BCM_TOPO_PON_SUB_FAMILY__NUM_OF,
+} bcm_topo_pon_sub_family;
+
+/* User context identifier - can be extended if more modules in the system use the bcm_topo.context. */
+typedef enum
+{
+    BCM_TOPO_PON_CONTEXT_ID_MAC_UTIL,
+    BCM_TOPO_PON_CONTEXT_ID_OMCI_SVC,
+    BCM_TOPO_PON_CONTEXT_ID_RSC_MGR,
+    BCM_TOPO_PON_CONTEXT_ID__NUM_OF,
+} bcm_topo_pon_context_id;
+
+typedef struct
+{
+    uint32_t num_of_devs;
+    uint32_t num_of_pons_per_dev;
+    bcm_topo_pon_mode pon_mode;
+} bcm_topo_params;
+
+/**
+ * @brief Get the PON mode of a given device ID.
+ * @param device_id            device ID
+ *
+ * @returns PON mode or Null on error
+ */
+const char *bcm_topo_dev_get_pon_mode_str(bcmolt_devid device_id);
+
+
+/**
+ * @brief Get the max number of pons of a given device ID.
+ * @param device_id            device ID
+ *
+ * @returns the max number of pons or -1 on error
+ */
+int bcm_topo_dev_get_max_pon(bcmolt_devid device_id);
+
+/**
+ * @brief Get the PON mode of a given logical PON ID.
+ * @param pon                 Logical PON ID
+ *
+ * @returns PON mode or BCM_TOPO_PON_MODE_INVALID on error
+ */
+bcm_topo_pon_mode bcm_topo_pon_get_pon_mode(uint32_t pon);
+
+/**
+ * @brief Get the PON family of a given logical PON ID.
+ * @param pon                 Logical PON ID
+ *
+ * @returns PON mode or BCM_TOPO_PON_FAMILY_INVALID on error
+ */
+bcm_topo_pon_family bcm_topo_pon_get_pon_family(uint32_t pon);
+
+/**
+ * @brief Get the PON sub-family of a given logical PON ID.
+ * @param pon                 Logical PON ID
+ *
+ * @returns PON mode or BCM_TOPO_PON_SUB_FAMILY_INVALID on error
+ */
+bcm_topo_pon_sub_family bcm_topo_pon_get_pon_sub_family(uint32_t pon);
+
+/**
+ * @brief Get the number of ONUs of a given logical PON ID.
+ * @param pon                 Logical PON ID
+ *
+ * @returns Number of ONUs or BCM_TOPO_ERR_INVALID on error
+ */
+uint32_t bcm_topo_pon_get_max_num_of_onus(uint32_t pon);
+
+/**
+ * @brief Return whether a given logical PON is in the valid range.
+ *
+ * @returns BCMOS_TRUE is the given logical PON is in the valid range, BCMOS_FALSE otherwise
+ */
+bcmos_bool bcm_topo_pon_is_valid(uint32_t pon);
+
+/**
+ * @brief Traverse devices
+ * @param device_id         Device iterator. Should be BCM_TOPO_DEV_INVALID at the beginning.
+ *
+ * @returns Next device, or BCM_TOPO_DEV_INVALID to mark that no more devices are available.
+ */
+bcmolt_devid bcm_topo_dev_get_next(bcmolt_devid device_id);
+
+/**
+ * @brief Traverse logical PONs within a given device.
+ * @param device_id         Device id
+ * @param pon               Logical PON iterator. Should be BCM_TOPO_PON_INVALID at the beginning.
+ *
+ * @returns Next logical PON on this device, or BCM_TOPO_PON_INVALID to mark that no more PONs are available.
+ */
+uint32_t bcm_topo_pon_get_next(bcmolt_devid device_id, uint32_t pon);
+
+/**
+ * @brief Get device ID and physical PON ID from logical PON ID.
+ * @param logical_pon            logical PON ID
+ * @param *device_id         Pointer to device id
+ * @param *physical_pon           Pointer to physical PON ID
+ *
+ * @returns bcmos_errno
+ * @note In general, the physical PON ID is used in the hardware directed function calls.
+ */
+bcmos_errno bcm_topo_pon_get_logical2physical(uint32_t logical_pon, bcmolt_devid *device_id, uint32_t *physical_pon);
+
+/**
+ * @brief Get logical PON ID from device ID and physical PON ID.
+ * @param device_id           Device id
+ * @param physical_pon             Physical PON ID
+ * @param *logical_pon            Pointer to logical PON ID
+ *
+ * @returns bcmos_errno
+ * @note In general, the logical PON ID is used in the BAL core directed function calls.
+ */
+bcmos_errno bcm_topo_pon_get_physical2logical(bcmolt_devid device_id, uint32_t physical_pon, uint32_t *logical_pon);
+
+/**
+ * @brief Set user context for a given logical PON ID.
+ * @param pon                 Logical PON ID
+ * @param pon_context_id      The identity of the module using the context
+ * @param context             Pointer to user context
+ *
+ * @returns bcmos_errno
+ */
+bcmos_errno bcm_topo_pon_set_context(uint32_t pon, bcm_topo_pon_context_id pon_context_id, void *context);
+
+/**
+ * @brief Get user context for a given logical PON ID.
+ * @param pon                 Logical PON ID
+ * @param pon_context_id      The identity of the module using the context
+ *
+ * @returns User context or NULL if there's an error
+ */
+void *bcm_topo_pon_get_context(uint32_t pon, bcm_topo_pon_context_id pon_context_id);
+
+/**
+ * @brief Initialize topology module, either by arguments (probably received from CLI) or by a topology file. The rule is at least one of them must be specified and exist. If both are
+ *        specified and exist, then we rely on topology file.
+ *        Pay attention that when not using a file, the user have less freedom. For example:
+ *        - The user won't be able to have devices with different PON modes.
+ *        - The user won't be able to have devices with different number of PONs.
+ *        - The user won't be able to map logical PON to (device, physical PON). We assume that logical_pon = (device * num_of_pons_per_dev) + physical_pon.
+ * @param params              Topology parameters. If NULL, we rely on topology file.
+ * @param topo_filename       File containing bcm_topo.configuration in a .csv format
+ *                            The columns are:
+ *                            Logical PON ID, PON Mode, Physical Device ID, Physical PON ID
+ *
+ * @returns bcmos_errno
+ */
+bcmos_errno bcm_topo_init(bcm_topo_params *params, const char *topo_filename);
+
+/**
+ * @brief Returns whether the topology module has been initialized.
+ *
+ * @returns BCMOS_TRUE if topology module has been initialized
+ */
+bcmos_bool bcm_topo_is_initialized(void);
+
+#define BCM_TOPO_MAX_NNI_PORTS 16
+
+/**
+ * @brief Set the max number of nnis of a given device ID.
+ * @param device_id            device ID
+ * @param num_nni_ports        nni ports on the device
+ *
+ * @returns BCMOS_TRUE 
+ */
+bcmos_bool bcm_topo_dev_set_max_nni(bcmolt_devid device_id, uint32_t num_nni_ports);
+
+/**
+ * @brief Get the max number of nnis of a given device ID.
+ * @param device_id            device ID
+ * @param p_num_nni_ports      pointer for the retrieved nni ports on the device
+ *
+ * @returns BCMOS_TRUE 
+ */
+bcmos_bool bcm_topo_dev_get_max_nni(bcmolt_devid device_id, uint32_t *p_num_nni_ports);
+
+/**
+ * @brief Return whether a given logical NNI is in the valid range.
+ *
+ * @returns BCMOS_TRUE is the given logical NNI is in the valid range, BCMOS_FALSE otherwise
+ */
+bcmos_bool bcm_topo_nni_is_valid(uint32_t nni);
+
+#endif
+