BAL and Maple Release 2.2
Signed-off-by: Shad Ansari <developer@Carbon.local>
diff --git a/bcm68620_release/release/host_customized/api_linux/Makefile b/bcm68620_release/release/host_customized/api_linux/Makefile
new file mode 100644
index 0000000..da617b5
--- /dev/null
+++ b/bcm68620_release/release/host_customized/api_linux/Makefile
@@ -0,0 +1,16 @@
+# Makefile for building utilities as linux module
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = api_linux
+MOD_TYPE = linux_lib
+MOD_DEPS = utils_linux sysmodel
+srcs = bcmolt_msg.c
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+endif
diff --git a/bcm68620_release/release/host_customized/api_linux/bcmolt_api.c b/bcm68620_release/release/host_customized/api_linux/bcmolt_api.c
new file mode 120000
index 0000000..4aea218
--- /dev/null
+++ b/bcm68620_release/release/host_customized/api_linux/bcmolt_api.c
@@ -0,0 +1 @@
+../../host_driver/api/bcmolt_api.c
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/api_linux/bcmolt_api.h b/bcm68620_release/release/host_customized/api_linux/bcmolt_api.h
new file mode 120000
index 0000000..fe53e25
--- /dev/null
+++ b/bcm68620_release/release/host_customized/api_linux/bcmolt_api.h
@@ -0,0 +1 @@
+../../host_driver/api/bcmolt_api.h
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/api_linux/bcmolt_msg.c b/bcm68620_release/release/host_customized/api_linux/bcmolt_msg.c
new file mode 120000
index 0000000..c3875f3
--- /dev/null
+++ b/bcm68620_release/release/host_customized/api_linux/bcmolt_msg.c
@@ -0,0 +1 @@
+../../host_driver/api/bcmolt_msg.c
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/api_linux/bcmolt_msg.h b/bcm68620_release/release/host_customized/api_linux/bcmolt_msg.h
new file mode 120000
index 0000000..546a74e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/api_linux/bcmolt_msg.h
@@ -0,0 +1 @@
+../../host_driver/api/bcmolt_msg.h
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/board/wrx/Makefile b/bcm68620_release/release/host_customized/board/wrx/Makefile
new file mode 100644
index 0000000..67d1e07
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/Makefile
@@ -0,0 +1,14 @@
+# Maple board specific configurations. Relevant only if working in Linux
+#
+MOD_TYPE = lib
+MOD_NAME = bcm_board
+
+ifeq ("$(OS_KERNEL)", "linux")
+ifeq ("$(ENABLE_CLI)", "y")
+
+MOD_DEPS = cli i2c_devs api_cli bcm_dev_ctrl_linux
+
+srcs = bcmolt_board.c bcmolt_board_cli.c
+endif
+endif
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/bcmolt_board.c b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board.c
new file mode 100644
index 0000000..479c5f9
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board.c
@@ -0,0 +1,702 @@
+/*
+<: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 <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <bcmcli.h>
+#include <bcmolt_i2c_devs_ioctl.h>
+#include <bcmolt_dev_ctrl_ioctl.h>
+#include <bcmolt_api.h>
+#include <bcmolt_model_types.h>
+#include <bcmolt_fld.h>
+#include "bcmolt_board.h"
+#include "bcmolt_dpll_table.h"
+
+#define BCM_I2C_DEV_ADDR_START typedef enum {
+#define BCM_I2C_DEV_ADDR(name, desc, val) name = val,
+#define BCM_I2C_DEV_ADDR_END } bcm_i2c_dev_addr;
+
+#define BCM_FPGA_REG_FPGA_VERSION 0x0
+#define BCM_FPGA_REG_BOARD_CONF 0x1
+#define BCM_FPGA_REG_RESETS 0x2
+/* Enable/disable transceiver */
+#define BCM_FPGA_REG_TRX_ENABLE 0x3
+#define BCM_FPGA_REG_TRX_FAIL 0x4
+/* Is transceiver present ? */
+#define BCM_FPGA_REG_TRX_IS_PRESENT 0x5
+#define BCM_FPGA_REG_CXP_CONTROLS 0x6
+#define BCM_FPGA_REG_SHIFT_REGISTER_DATA 0x7
+#define BCM_FPGA_REG_SHIFT_REGISTER_CONTROL 0x8
+#define BCM_FPGA_REG_LEDS 0x9
+#define BCM_FPGA_REG_DEBUG_LEDS 0xA
+#define BCM_FPGA_REG_GPIO_DIR 0xB
+#define BCM_FPGA_REG_GPIO_INPUT 0xC
+#define BCM_FPGA_REG_GPIO_OUTPUT 0xD
+#define BCM_FPGA_REG_GPIO_IRQ 0xE
+
+#define BCM_FPGA_REG_LOW BCM_FPGA_REG_FPGA_VERSION
+#define BCM_FPGA_REG_HIGH BCM_FPGA_REG_GPIO_IRQ
+
+#define BCM_RST_BIT_DEVICE 0x0
+#define BCM_RST_BIT_PON_DPLL 0x1
+#define BCM_RST_BIT_PM_DPLL 0x2
+#define BCM_RST_BIT_KT2 0x4
+
+#define SVK4_IDENT_FILE "/etc/svk4"
+
+#include <bcmolt_i2c_devs_addr.h>
+
+#define MAX_CMD_STR_LEN 1024
+
+/* Since the board driver configuration is specific for Linux, there is no point using OS abstraction layer to perform operations like ioctl(). */
+
+static int maple_i2c_fd;
+static int maple_dev_ctrl_fd;
+
+static bcmos_bool bcm_board_is_svk4(void)
+{
+ bcmos_bool is_svk4 = BCMOS_FALSE;
+ FILE *f = fopen(SVK4_IDENT_FILE, "r");
+ if (f)
+ {
+ is_svk4 = BCMOS_TRUE;
+ fclose(f);
+ }
+ return is_svk4;
+}
+
+static bcmos_errno bcm_access_fpga(void)
+{
+ bcmos_errno rc;
+ if (bcm_board_is_svk4())
+ {
+ rc = bcm_board_dev_change(I2C_SW1_I2C_ADDR);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_change(I2C_SW1_I2C_ADDR) failed\n");
+ rc = bcm_board_switch_write(0x4);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_switch_write(1) failed\n");
+ }
+ else
+ {
+ rc = bcm_board_dev_change(I2C_SW0_I2C_ADDR);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_change(I2C_SW0_I2C_ADDR) failed\n");
+ rc = bcm_board_switch_write(1);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_switch_write(1) failed\n");
+ }
+ rc = bcm_board_dev_change(FPGA_I2C_ADDR);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_change(FPGA_I2C_ADDR) failed \n");
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_dev_change(uint32_t addr)
+{
+ int rc;
+ maple_i2c_ioctl_param params =
+ {
+ .addr = addr,
+ };
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_CHANGE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for maple_i2c_fd\n");
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_dev_write(uint32_t count, uint32_t addr, uint32_t val)
+{
+ int rc;
+ maple_i2c_ioctl_param params =
+ {
+ .count = count,
+ .addr = addr,
+ .val = val,
+ };
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for maple_i2c_fd\n");
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_dev_read(uint32_t count, uint32_t addr, uint32_t *val)
+{
+ int rc;
+ maple_i2c_ioctl_param params =
+ {
+ .count = count,
+ .addr = addr,
+ };
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_READ, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for maple_i2c_fd\n");
+ *val = params.val;
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_switch_write(uint32_t val)
+{
+ int rc;
+ maple_i2c_ioctl_param params =
+ {
+ .val = val,
+ };
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_SWITCH_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for maple_i2c_fd\n");
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_switch_read(uint32_t *val)
+{
+ int rc;
+ maple_i2c_ioctl_param params = {};
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_SWITCH_READ, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for maple_i2c_fd\n");
+ *val = params.val;
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_fpga_write(uint32_t addr, uint32_t val)
+{
+ int rc;
+ maple_i2c_ioctl_param params =
+ {
+ .addr = addr,
+ .val = val,
+ };
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_FPGA_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for fpga_write\n");
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_host_event_write(uint32_t val)
+{
+ int rc;
+ dev_ctrl_ioctl_param params =
+ {
+ .event = val,
+ };
+
+ rc = ioctl(maple_dev_ctrl_fd, MAPLE_DEV_CTRL_IOCTL_OP_HOST_EVENT_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for host_event_write\n");
+
+#ifdef CONFIG_ONU_SIM
+ /* Raise an interrupt on ext_irq1 for the embedded side. */
+ rc = bcm_board_fpga_gen_gpio_irq(BCMOLT_EXT_IRQ_EXT_IRQ1);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for bcm_board_fpga_gen_gpio_irq\n");
+#endif
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_pci_debug(uint32_t device, uint32_t command, int32_t start, int32_t howmany, uint32_t *dumpptr)
+{
+ int rc;
+ dev_ctrl_ioctl_param params =
+ {
+ .device = device,
+ .dumpptr = dumpptr,
+ .start_index = start,
+ .howmany = howmany
+ };
+
+ rc = ioctl(maple_dev_ctrl_fd, command, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for dev_ctrl\n");
+
+ return BCM_ERR_OK;
+}
+bcmos_errno bcm_board_fpga_read(uint32_t addr, uint32_t *val)
+{
+ int rc;
+ maple_i2c_ioctl_param params =
+ {
+ .addr = addr,
+ };
+
+ rc = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_FPGA_READ, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rc, BCM_ERR_INTERNAL, "ioctl failed for fpga_read\n");
+ *val = params.val;
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_fpga_reg_read(uint32_t reg, uint32_t *val)
+{
+ bcmos_errno rc;
+
+ if (reg > BCM_FPGA_REG_HIGH)
+ return BCM_ERR_RANGE;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ return bcm_board_fpga_read(reg, val);
+}
+
+bcmos_errno bcm_board_fpga_reg_write(uint32_t reg, uint32_t val)
+{
+ bcmos_errno rc;
+
+ if (reg > BCM_FPGA_REG_HIGH)
+ return BCM_ERR_RANGE;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ return bcm_board_fpga_write(reg, val);
+}
+
+bcmos_errno bcm_board_fpga_version_get(uint32_t *version)
+{
+ bcmos_errno rc;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ return bcm_board_fpga_read(BCM_FPGA_REG_FPGA_VERSION, version);
+}
+
+bcmos_errno bcm_board_fpga_set_gpio_dir(bcmolt_gpio_pin gpio_pin, bcm_fpga_gpio_dir dir)
+{
+ bcmos_errno rc;
+ uint32_t gpio_dir_mask;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ /* Read-modify-write direction register (we don't want to affect other GPIO's). */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_GPIO_DIR, &gpio_dir_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ if (dir == BCM_FPGA_GPIO_DIR_INPUT)
+ gpio_dir_mask &= ~(1 << (gpio_pin - BCMOLT_GPIO_PIN_PIN4));
+ else
+ gpio_dir_mask |= (1 << (gpio_pin - BCMOLT_GPIO_PIN_PIN4));
+
+ return bcm_board_fpga_write(BCM_FPGA_REG_GPIO_DIR, gpio_dir_mask);
+}
+
+bcmos_errno bcm_board_fpga_get_gpio_dir(bcmolt_gpio_pin gpio_pin, bcm_fpga_gpio_dir *dir)
+{
+ bcmos_errno rc;
+ uint32_t gpio_dir_mask;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_GPIO_DIR, &gpio_dir_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ *dir = (gpio_dir_mask & (1 << (gpio_pin - BCMOLT_GPIO_PIN_PIN4))) ? BCM_FPGA_GPIO_DIR_OUTPUT : BCM_FPGA_GPIO_DIR_INPUT;
+
+ return rc;
+}
+
+bcmos_errno bcm_board_fpga_write_gpio(bcmolt_gpio_pin gpio_pin, uint32_t val)
+{
+ bcmos_errno rc;
+ uint32_t gpio_write_mask;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ /* Read-modify-write direction register (we don't want to affect other GPIO's). */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_GPIO_OUTPUT, &gpio_write_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ if (!val)
+ gpio_write_mask &= ~(1 << (gpio_pin - BCMOLT_GPIO_PIN_PIN4));
+ else
+ gpio_write_mask |= (1 << (gpio_pin - BCMOLT_GPIO_PIN_PIN4));
+
+ return bcm_board_fpga_write(BCM_FPGA_REG_GPIO_OUTPUT, gpio_write_mask);
+}
+
+bcmos_errno bcm_board_fpga_read_gpio(bcmolt_gpio_pin gpio_pin, uint32_t *val)
+{
+ bcmos_errno rc;
+ uint32_t gpio_read_mask;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_GPIO_INPUT, &gpio_read_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ *val = (gpio_read_mask & (1 << (gpio_pin - BCMOLT_GPIO_PIN_PIN4)));
+
+ return rc;
+}
+
+bcmos_errno bcm_board_fpga_gen_gpio_irq(bcmolt_ext_irq ext_irq)
+{
+ bcmos_errno rc;
+ uint32_t gpio_irq_mask;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ /* Read-modify-write direction register (we don't want to affect other GPIO's). */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_GPIO_IRQ, &gpio_irq_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ gpio_irq_mask |= (1 << ext_irq);
+ rc = bcm_board_fpga_write(BCM_FPGA_REG_GPIO_IRQ, gpio_irq_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ bcmos_usleep(1000);
+
+ gpio_irq_mask &= ~(1 << ext_irq);
+ rc = bcm_board_fpga_write(BCM_FPGA_REG_GPIO_IRQ, gpio_irq_mask);
+
+ return rc;
+}
+
+bcmos_errno bcm_board_trx_present(uint8_t pon)
+{
+ bcmos_errno rc;
+ uint32_t trx_absence_mask;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ /* Check that the transceiver is present (plugged in). For ONU simulator, we allow working without transceivers. */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_TRX_IS_PRESENT, &trx_absence_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ if (trx_absence_mask & (1 << pon))
+ {
+ /* The transceiver is absent. */
+ return BCM_ERR_NODEV;
+ }
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_trx_enable(uint8_t pon, bcmos_bool is_enabled)
+{
+#ifdef CONFIG_ONU_SIM
+ static uint32_t trx_disable_mask = 0xFFFFFFFF;
+
+ /* Keep track of which TRXs are logically enabled. */
+ if (is_enabled)
+ trx_disable_mask &= ~(1 << pon);
+ else
+ trx_disable_mask |= (1 << pon);
+
+ return bcm_board_host_event_write(trx_disable_mask);
+#else
+ uint32_t trx_disable_mask;
+ uint32_t trx_absence_mask;
+
+ bcmos_errno rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ /* Check that the transceiver is present (plugged in). */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_TRX_IS_PRESENT, &trx_absence_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ if (trx_absence_mask & (1 << pon))
+ {
+ /* The transceiver is absent. */
+ return BCM_ERR_NODEV;
+ }
+
+ /* Read-modify-write transceiver disable mask (we don't want to affect other PON's). */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_TRX_ENABLE, &trx_disable_mask);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ if (is_enabled == BCMOS_TRUE)
+ trx_disable_mask &= ~(1 << pon);
+ else
+ trx_disable_mask |= (1 << pon);
+
+ rc = bcm_board_fpga_write(BCM_FPGA_REG_TRX_ENABLE, trx_disable_mask);
+ if (rc != BCM_ERR_OK)
+ return BCM_ERR_INTERNAL;
+ return bcm_board_host_event_write(trx_disable_mask);
+#endif
+}
+
+static bcmos_errno bcm_board_config_reset_value(uint32_t rst_bit, bcmos_bool is_on)
+{
+ bcmos_errno rc;
+ uint32_t reset_values;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ /* Read-modify-write so we can set only the relevant bit to 0 */
+ rc = bcm_board_fpga_read(BCM_FPGA_REG_RESETS, &reset_values);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ if (is_on == BCMOS_TRUE)
+ reset_values |= 1 << rst_bit;
+ else
+ reset_values &= ~(1 << rst_bit);
+
+ return bcm_board_fpga_write(BCM_FPGA_REG_RESETS, reset_values);
+}
+
+static bcmos_errno device_disconnect(void)
+{
+ bcmolt_device_key key = {};
+ bcmolt_device_cfg dev_cfg;
+ bcmolt_device_disconnect dev_disconnect;
+ bcmos_errno rc;
+
+ BCMOLT_CFG_INIT(&dev_cfg, device, key);
+ BCMOLT_CFG_PROP_GET(&dev_cfg, device, state);
+ rc = bcmolt_cfg_get(0, &dev_cfg.hdr);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ if (dev_cfg.data.state != BCMOLT_DEVICE_STATE_DISCONNECTED)
+ {
+ BCMOLT_OPER_INIT(&dev_disconnect, device, disconnect, key);
+ return bcmolt_oper_submit(0, &dev_disconnect.hdr);
+ }
+ else
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_device_reset(void)
+{
+ bcmos_errno rc;
+
+ rc = device_disconnect();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ rc = bcm_board_config_reset_value(BCM_RST_BIT_DEVICE, BCMOS_FALSE);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ return bcm_board_config_reset_value(BCM_RST_BIT_DEVICE, BCMOS_TRUE);
+}
+
+/* Device on keeps the reset bit on active high */
+bcmos_errno bcm_board_device_on(void)
+{
+ return bcm_board_config_reset_value(BCM_RST_BIT_DEVICE, BCMOS_TRUE);
+}
+
+/* Device off keeps the reset bit on active low */
+bcmos_errno bcm_board_device_off(void)
+{
+ bcmos_errno rc;
+
+ rc = device_disconnect();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ return bcm_board_config_reset_value(BCM_RST_BIT_DEVICE, BCMOS_FALSE);
+}
+
+/* Katana2 Device on keeps the reset bit on active high */
+bcmos_errno bcm_board_kt2_device_on(void)
+{
+ /* take the KT2 out of reset */
+ return bcm_board_config_reset_value(BCM_RST_BIT_KT2, BCMOS_TRUE);
+}
+
+/* Device off keeps the reset bit on active low */
+bcmos_errno bcm_board_kt2_device_off(void)
+{
+ return bcm_board_config_reset_value(BCM_RST_BIT_KT2, BCMOS_FALSE);
+}
+
+static bcmos_errno bcm_access_dpll(void)
+{
+ bcmos_errno rc;
+
+ if (bcm_board_is_svk4())
+ {
+ rc = bcm_board_dev_change(I2C_SW1_I2C_ADDR);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_change(I2C_SW1_I2C_ADDR) failed\n");
+ rc = bcm_board_switch_write(0x20);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_switch_write(0x20) failed\n");
+ }
+ else
+ {
+ rc = bcm_board_dev_change(I2C_SW0_I2C_ADDR);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_change(I2C_SW0_I2C_ADDR) failed\n");
+ rc = bcm_board_switch_write(2);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_switch_write(2) failed\n");
+ }
+
+ rc = bcm_board_dev_change(PON_DPLL_I2C_ADDR);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_change(PON_DPLL_I2C_ADDR) failed \n");
+
+ return rc;
+}
+
+static int bcm_board_set_page_dpll(uint32_t page)
+{
+ int rcioctl;
+ maple_i2c_ioctl_param params =
+ {
+ .count = 8,
+ .addr = 1,
+ .val = page,
+ };
+
+ rcioctl = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rcioctl, BCM_ERR_INTERNAL, "ioctl write change page failed\n");
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_read_dpll(uint32_t page, uint32_t reg, uint32_t *val)
+{
+ bcmos_errno rc;
+ int rcioctl;
+ maple_i2c_ioctl_param params =
+ {
+ .count = 8,
+ .addr = reg,
+ .val = 0,
+ };
+
+ rc = bcm_access_dpll();
+ bcm_board_set_page_dpll(page);
+ rcioctl = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_READ, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rcioctl, BCM_ERR_INTERNAL, "ioctl read failed for maple_i2c_fd\n");
+ *val = params.val;
+
+ return rc;
+}
+
+bcmos_errno bcm_board_write_dpll(uint32_t page, uint32_t reg, uint32_t val)
+{
+ bcmos_errno rc;
+ int rcioctl;
+ maple_i2c_ioctl_param params =
+ {
+ .count = 8,
+ .addr = reg,
+ .val = val,
+ };
+
+ rc = bcm_access_dpll();
+ bcm_board_set_page_dpll(page);
+ rcioctl = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rcioctl, BCM_ERR_INTERNAL, "ioctl write failed for maple_i2c_fd\n");
+
+ return rc;
+}
+
+static bcmos_errno bcm_board_load_dpll(dpll_command *commands, int cmdlen)
+{
+ int rcioctl,i;
+ bcmos_errno rc;
+ uint8_t previous_page = 0;
+
+ maple_i2c_ioctl_param params =
+ {
+ .count = 8,
+ .addr = 0,
+ .val = 0,
+ };
+
+ rc = bcm_access_dpll();
+ for (i=0; i < cmdlen; i++)
+ {
+ if (commands[i].page != previous_page)
+ {
+ bcm_board_set_page_dpll(commands[i].page);
+ previous_page = commands[i].page;
+ }
+ params.addr = commands[i].reg;
+ params.val = commands[i].data;
+ rcioctl = ioctl(maple_i2c_fd, MAPLE_I2C_IOCTL_OP_DEV_WRITE, ¶ms);
+ BCMOS_TRACE_CHECK_RETURN(rcioctl, BCM_ERR_INTERNAL, "ioctl write data page failed\n");
+ }
+ return rc;
+}
+bcmos_errno bcm_board_burn_pon_dpll(bcm_dpll_users dpll_dev)
+{
+ switch(dpll_dev)
+ {
+ case GPON_DPLL:
+ return bcm_board_load_dpll(gpon_dpll_table,sizeof(gpon_dpll_table)/sizeof(dpll_command));
+ break;
+ case EPON_DPLL:
+ return bcm_board_load_dpll(epon_dpll_table,sizeof(epon_dpll_table)/sizeof(dpll_command));
+ break;
+ case GPON_SYNCE:
+ return bcm_board_load_dpll(gpon_synce_dpll_table,sizeof(gpon_synce_dpll_table)/sizeof(dpll_command));
+ break;
+ default:
+ break;
+ }
+
+ return BCM_ERR_PARM;
+}
+
+bcmos_errno bcm_board_init(void)
+{
+ maple_dev_ctrl_fd = open("/dev/maple_dev_ctrl", O_RDWR);
+ BCMOS_TRACE_CHECK_RETURN(maple_dev_ctrl_fd < 0, errno, "maple_dev_ctrl_fd open failed\n");
+
+ maple_i2c_fd = open("/dev/maple_i2c", O_RDWR);
+ BCMOS_TRACE_CHECK_RETURN(maple_i2c_fd < 0, errno, "maple_i2c_fd open failed\n");
+
+#ifdef CONFIG_ONU_SIM
+ /* If the ONU sim is running, always leave all transceivers physically disabled. */
+ bcmos_errno rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ rc = bcm_board_fpga_write(BCM_FPGA_REG_TRX_ENABLE, 0xFFFFFFFF);
+ if (rc != BCM_ERR_OK)
+ return BCM_ERR_INTERNAL;
+#endif
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_get_board_id(bcm_board_svk_board_id * board_id)
+{
+ bcmos_errno rc;
+ uint32_t val;
+
+ rc = bcm_access_fpga();
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ rc = bcm_board_fpga_read(0x1, &val);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+
+ *board_id = val & 0x7;
+ return BCM_ERR_OK;
+}
+
+void bcm_board_uninit(void)
+{
+ close(maple_i2c_fd);
+ maple_i2c_fd = 0;
+
+ close(maple_dev_ctrl_fd);
+ maple_dev_ctrl_fd = -1;
+}
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/bcmolt_board.h b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board.h
new file mode 100644
index 0000000..3a58eba
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board.h
@@ -0,0 +1,100 @@
+/*
+<: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_BOARD_H_
+#define _BCMOLT_BOARD_H_
+
+#include <bcmos_system.h>
+#include <bcmolt_model_types.h>
+
+typedef enum
+{
+ SVK_1 = 0x7, /* SVK #1 - BCM968620S: all PON flavors supported, SFP+ */
+ SVK_2_XG = 0x6, /* SVK #2 - BCM968620XG: XGPON */
+ SVK_2_XE = 0x5, /* SVK #2 - BCM968620XE: 10G EPON */
+ SVK_3 = 0x4, /* SVK #3 - BCM968620K: all PON flavors supported, XFP */
+} bcm_board_svk_board_id;
+
+bcmos_errno bcm_board_dev_change(uint32_t addr);
+bcmos_errno bcm_board_dev_write(uint32_t count, uint32_t addr, uint32_t val);
+bcmos_errno bcm_board_dev_read(uint32_t count, uint32_t addr, uint32_t *val);
+bcmos_errno bcm_board_switch_write(uint32_t val);
+bcmos_errno bcm_board_switch_read(uint32_t *val);
+bcmos_errno bcm_board_fpga_write(uint32_t addr, uint32_t val);
+bcmos_errno bcm_board_fpga_read(uint32_t addr, uint32_t *val);
+bcmos_errno bcm_board_host_event_write(uint32_t val);
+
+bcmos_errno bcm_board_fpga_version_get(uint32_t *version);
+
+/* FPGA GPIO access */
+typedef enum
+{
+ BCM_FPGA_GPIO_DIR_INPUT,
+ BCM_FPGA_GPIO_DIR_OUTPUT,
+} bcm_fpga_gpio_dir;
+
+typedef enum
+{
+ GPON_DPLL,
+ EPON_DPLL,
+ GPON_SYNCE
+} bcm_dpll_users;
+
+typedef struct
+{
+ uint8_t page;
+ uint8_t reg;
+ uint8_t data;
+} dpll_command;
+
+bcmos_errno bcm_board_fpga_set_gpio_dir(bcmolt_gpio_pin gpio_pin, bcm_fpga_gpio_dir dir);
+bcmos_errno bcm_board_fpga_get_gpio_dir(bcmolt_gpio_pin gpio_pin, bcm_fpga_gpio_dir *dir);
+bcmos_errno bcm_board_fpga_write_gpio(bcmolt_gpio_pin gpio_pin, uint32_t val);
+bcmos_errno bcm_board_fpga_read_gpio(bcmolt_gpio_pin gpio_pin, uint32_t *val);
+bcmos_errno bcm_board_fpga_gen_gpio_irq(bcmolt_ext_irq ext_irq);
+
+bcmos_errno bcm_board_trx_enable(uint8_t pon, bcmos_bool is_enabled);
+bcmos_errno bcm_board_trx_present(uint8_t pon);
+bcmos_errno bcm_board_device_reset(void);
+bcmos_errno bcm_board_device_on(void);
+bcmos_errno bcm_board_device_off(void);
+bcmos_errno bcm_board_kt2_device_on(void);
+bcmos_errno bcm_board_kt2_device_off(void);
+bcmos_errno bcm_board_get_board_id(bcm_board_svk_board_id * board_id);
+bcmos_errno bcm_board_fpga_reg_read(uint32_t reg, uint32_t *val);
+bcmos_errno bcm_board_fpga_reg_write(uint32_t reg, uint32_t val);
+bcmos_errno bcm_board_pci_debug(uint32_t device, uint32_t command, int32_t start, int32_t howmany, uint32_t *dumpptr);
+bcmos_errno bcm_board_burn_pon_dpll(bcm_dpll_users dpll_dev);
+bcmos_errno bcm_board_write_dpll(uint32_t page, uint32_t reg, uint32_t val);
+bcmos_errno bcm_board_read_dpll(uint32_t page, uint32_t reg, uint32_t *val);
+
+bcmos_errno bcm_board_init(void);
+void bcm_board_uninit(void);
+
+#endif
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/bcmolt_board_cli.c b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board_cli.c
new file mode 100644
index 0000000..e7b59fa
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board_cli.c
@@ -0,0 +1,581 @@
+/*
+<: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 <bcmcli.h>
+#include "bcmolt_board.h"
+#include "bcmolt_board_cli.h"
+#include <arpa/inet.h>
+
+#define BCM_I2C_DEV_ADDR_START static bcmcli_enum_val bcm_i2c_dev_addr_table[] = {
+#define BCM_I2C_DEV_ADDR(name, desc, val) {desc, val},
+#define BCM_I2C_DEV_ADDR_END BCMCLI_ENUM_LAST};
+#include <bcmolt_i2c_devs_addr.h>
+
+static bcmos_errno bcm_board_cli_dev_change(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t addr = bcmcli_find_named_parm(session, "dev")->value.unumber;
+
+ return bcm_board_dev_change(addr);
+}
+
+static bcmos_errno bcm_board_cli_dev_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t count = bcmcli_find_named_parm(session, "width")->value.unumber;
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
+
+ switch (count)
+ {
+ case 8:
+ case 16:
+ case 32:
+ break;
+ default:
+ bcmcli_session_print(session, "Count can be 8|16|32\n");
+ return BCM_ERR_PARM;
+ }
+ return bcm_board_dev_write(count, addr, val);
+}
+
+static bcmos_errno bcm_board_cli_dev_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t count = bcmcli_find_named_parm(session, "width")->value.unumber;
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val;
+ bcmos_errno rc;
+
+ switch (count)
+ {
+ case 8:
+ case 16:
+ case 32:
+ break;
+ default:
+ bcmcli_session_print(session, "Count can be 8|16|32\n");
+ return BCM_ERR_PARM;
+ }
+ rc = bcm_board_dev_read(count, addr, &val);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dev_read() failed\n");
+ bcmcli_session_print(session, "0x%x\n", val);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno bcm_board_cli_switch_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
+
+ return bcm_board_switch_write(val);
+}
+
+static bcmos_errno bcm_board_cli_switch_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t val;
+ bcmos_errno rc;
+
+ rc = bcm_board_switch_read(&val);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_switch_read() failed\n");
+ bcmcli_session_print(session, "0x%x\n", val);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno bcm_board_cli_fpga_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
+
+ return bcm_board_fpga_write(addr, val);
+}
+
+static bcmos_errno bcm_board_cli_fpga_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val;
+ bcmos_errno rc;
+
+ rc = bcm_board_fpga_read(addr, &val);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_fpga_read() failed\n");
+ bcmcli_session_print(session, "0x%x\n", val);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno bcm_board_cli_fpga_version(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t version;
+ bcmos_errno rc;
+
+ rc = bcm_board_fpga_version_get(&version);
+ bcmcli_session_print(session, "0x%x\n", version);
+ return rc;
+}
+
+static bcmos_errno bcm_board_cli_fpga_set_gpio_dir(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
+ bcm_fpga_gpio_dir dir = bcmcli_find_named_parm(session, "dir")->value.unumber;
+
+ return bcm_board_fpga_set_gpio_dir(gpio_pin, dir);
+}
+
+static bcmos_errno bcm_board_cli_fpga_get_gpio_dir(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
+ bcm_fpga_gpio_dir dir;
+ bcmos_errno rc;
+
+ rc = bcm_board_fpga_get_gpio_dir(gpio_pin, &dir);
+ bcmcli_session_print(session, "%s\n", dir == BCM_FPGA_GPIO_DIR_INPUT ? "input" : "output");
+ return rc;
+}
+
+static bcmos_errno bcm_board_cli_fpga_write_gpio(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
+ uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
+
+ return bcm_board_fpga_write_gpio(gpio_pin, val);
+}
+
+static bcmos_errno bcm_board_cli_fpga_read_gpio(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ bcmolt_gpio_pin gpio_pin = bcmcli_find_named_parm(session, "gpio_pin")->value.unumber;
+ uint32_t val;
+ bcmos_errno rc;
+
+ rc = bcm_board_fpga_read_gpio(gpio_pin, &val);
+ bcmcli_session_print(session, "0x%x\n", val);
+ return rc;
+}
+
+static bcmos_errno bcm_board_cli_fpga_gen_gpio_irq(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ bcmolt_ext_irq ext_irq = bcmcli_find_named_parm(session, "irq")->value.unumber;
+
+ return bcm_board_fpga_gen_gpio_irq(ext_irq);
+}
+
+static bcmos_errno bcm_board_cli_trx_enable(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint8_t pon_id = bcmcli_find_named_parm(session, "pon_id")->value.unumber;
+
+ return bcm_board_trx_enable(pon_id, BCMOS_TRUE);
+}
+
+static bcmos_errno bcm_board_cli_trx_disable(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint8_t pon_id = bcmcli_find_named_parm(session, "pon_id")->value.unumber;
+
+ return bcm_board_trx_enable(pon_id, BCMOS_FALSE);
+}
+
+static bcmos_errno bcm_board_cli_device_reset(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ return bcm_board_device_reset();
+}
+
+static bcmos_errno bcm_board_cli_device_on(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ return bcm_board_device_on();
+}
+
+static bcmos_errno bcm_board_cli_device_off(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ return bcm_board_device_off();
+}
+
+static bcmos_errno bcm_board_cli_kt2_on(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ return bcm_board_kt2_device_on();
+}
+
+static bcmos_errno bcm_board_cli_kt2_off(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ return bcm_board_kt2_device_off();
+}
+
+static bcmos_errno bcm_board_cli_fpga_reg_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val;
+ bcmos_errno rc;
+
+ rc = bcm_board_fpga_reg_read(addr, &val);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_fpga_reg_read() failed\n");
+ bcmcli_session_print(session, "0x%x\n", val);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno bcm_board_cli_fpga_reg_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
+
+ return bcm_board_fpga_reg_write(addr, val);
+}
+
+static bcmos_errno bcm_board_cli_burn_dpll(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ bcmos_errno rc;
+
+ uint32_t dev = bcmcli_find_named_parm(session, "device")->value.unumber;
+ rc = bcm_board_burn_pon_dpll(dev);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_burn_pon_dpll() failed\n");
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno bcm_board_cli_dpll_write(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t page = bcmcli_find_named_parm(session, "page")->value.unumber;
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val = bcmcli_find_named_parm(session, "val")->value.unumber;
+
+ return bcm_board_write_dpll(page, addr, val);
+}
+
+static bcmos_errno bcm_board_cli_dpll_read(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ uint32_t page = bcmcli_find_named_parm(session, "page")->value.unumber;
+ uint32_t addr = bcmcli_find_named_parm(session, "addr")->value.unumber;
+ uint32_t val;
+ bcmos_errno rc;
+
+ rc = bcm_board_read_dpll(page, addr, &val);
+ BCMOS_TRACE_CHECK_RETURN(rc, rc, "bcm_board_dpll_read() failed\n");
+ bcmcli_session_print(session, "0x%x\n", val);
+
+ return BCM_ERR_OK;
+}
+
+/* LUK_MAX_DATA_SIZE (2*1024) */
+#define SWITCH_RECEIVE_BUFFER_LENGTH (2*1024)
+static int switch_socket = -1;
+static char *switch_buffer = NULL;
+static bcmos_bool switch_first_connection = BCMOS_TRUE;
+
+static void switch_response(bcmcli_session *session)
+{
+ int len;
+ char *prompt = NULL;
+
+ while (1)
+ {
+ len = read(switch_socket, switch_buffer, SWITCH_RECEIVE_BUFFER_LENGTH-1);
+ if (len > 0)
+ {
+ switch_buffer[len] = '\0';
+ bcmcli_print(session, "%s", switch_buffer);
+ prompt = strstr(switch_buffer, "BCM");
+ while (prompt)
+ {
+ len = strlen(prompt);
+ if (len >= 6)
+ {
+ if ((prompt[3] == '>') || ((prompt[3] == '.') && (prompt[5] == '>')))
+ return;
+ }
+ else if (len >= 4)
+ {
+ if (prompt[3] == '>')
+ return;
+ }
+ prompt = strstr(&prompt[2], "BCM");
+ }
+ }
+ else
+ break;
+ }
+}
+
+static bcmos_errno kt2_conn(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ struct sockaddr_in server;
+
+ if (switch_socket != -1)
+ {
+ bcmcli_print(session, "A connection already exists\n");
+ return BCM_ERR_ALREADY;
+ }
+
+ switch_buffer = bcmos_alloc(SWITCH_RECEIVE_BUFFER_LENGTH);
+ if (!switch_buffer)
+ {
+ bcmcli_print(session, "Failed to allocate buffer\n");
+ return BCM_ERR_NOMEM;
+ }
+ memset((void *)&server, 0, sizeof(server));
+ server.sin_family = AF_INET;
+ server.sin_port = htons(parm[0].value.number);
+ server.sin_addr.s_addr = inet_addr("127.0.0.1");
+ switch_socket = socket(AF_INET, SOCK_STREAM, 0);
+ if (switch_socket < 0)
+ {
+ bcmcli_print(session, "Can't open client socket\n");
+ goto exit;
+ }
+ if (connect(switch_socket, (struct sockaddr *)&server, sizeof(server)) == -1)
+ {
+ close(switch_socket);
+ bcmcli_print(session, "Failed to connect\n");
+ goto exit;
+ }
+ if (switch_first_connection)
+ {
+ switch_first_connection = BCMOS_FALSE;
+ switch_response(session);
+ }
+
+ return BCM_ERR_OK;
+
+exit:
+ bcmos_free(switch_buffer);
+ return BCM_ERR_COMM_FAIL;
+}
+
+static bcmos_errno kt2_disconn(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ if (switch_socket != -1)
+ {
+ bcmcli_print(session, "Send 'exit'\n");
+ if (write(switch_socket, "exit\r", strlen("exit\r")) < 0)
+ bcmcli_print(session, "Send 'exit' to switch failed\n");
+ fsync(switch_socket);
+ }
+ bcmos_usleep(1000);
+ if (switch_socket != -1)
+ close(switch_socket);
+ if (switch_buffer)
+ bcmos_free(switch_buffer);
+ /* set socket and buffer with initial values */
+ switch_socket = -1;
+ switch_buffer = NULL;
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno kt2_cmd(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t n_parms)
+{
+ int len, sent_len;
+ char *str;
+
+ if ((switch_socket == -1) || (!switch_buffer))
+ {
+ bcmcli_print(session, "Connection or buffer do not exist\n");
+ return BCM_ERR_NORES;
+ }
+ /* switch user space application receives thru _fd_input_cb and
+ send to kernel thru _kernel_proxy_output_cb */
+ len = (int)strlen(parm[0].value.string);
+ {
+ /* dirty - just to avoid error : cast discards '__attribute__((const))' qualifier if useing strcat */
+ unsigned long strp = (unsigned long)&parm[0].value.string;
+ str = *(char **)strp;
+ }
+ str[len++] = '\r';
+ str[len] = '\0';
+ sent_len = 0;
+ do
+ {
+ sent_len = write(switch_socket, str + sent_len , len - sent_len);
+ if (sent_len == -1 || ((sent_len == 0) && errno))
+ {
+ bcmcli_print(session, "Send command to switch failed (write to socket error: %d)\n", errno);
+ return BCM_ERR_COMM_FAIL;
+ }
+ fsync(switch_socket);
+ } while(len - sent_len);
+ /* switch kernel send thru _kernel_proxy_input_cb
+ to switch user space application thru _fd_outout_cb */
+ switch_response(session);
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_board_cli_init(bcmcli_entry *top_dir)
+{
+ bcmcli_entry *board_dir, *i2c_dir;
+ bcmos_errno rc;
+ bcm_board_svk_board_id board_id;
+ bcmcli_entry *dir;
+ static bcmcli_enum_val fpga_gpio_pin_table[] =
+ {
+ {"pin4", BCMOLT_GPIO_PIN_PIN4},
+ {"pin5", BCMOLT_GPIO_PIN_PIN5},
+ {"pin6", BCMOLT_GPIO_PIN_PIN6},
+ {"pin7", BCMOLT_GPIO_PIN_PIN7},
+ {"pin8", BCMOLT_GPIO_PIN_PIN8},
+ {"pin9", BCMOLT_GPIO_PIN_PIN9},
+ {"pin10", BCMOLT_GPIO_PIN_PIN10},
+ {"pin11", BCMOLT_GPIO_PIN_PIN11},
+ {"pin12", BCMOLT_GPIO_PIN_PIN12},
+ {"pin13", BCMOLT_GPIO_PIN_PIN13},
+ {"pin14", BCMOLT_GPIO_PIN_PIN14},
+ {"pin15", BCMOLT_GPIO_PIN_PIN15},
+ {"pin16", BCMOLT_GPIO_PIN_PIN16},
+ {"pin17", BCMOLT_GPIO_PIN_PIN17},
+ {"pin18", BCMOLT_GPIO_PIN_PIN18},
+ {"pin19", BCMOLT_GPIO_PIN_PIN19},
+ {"pin20", BCMOLT_GPIO_PIN_PIN20},
+ {"pin21", BCMOLT_GPIO_PIN_PIN21},
+ {"pin22", BCMOLT_GPIO_PIN_PIN22},
+ {"pin23", BCMOLT_GPIO_PIN_PIN23},
+ {"pin24", BCMOLT_GPIO_PIN_PIN24},
+ {"pin25", BCMOLT_GPIO_PIN_PIN25},
+ {"pin26", BCMOLT_GPIO_PIN_PIN26},
+ {"pin27", BCMOLT_GPIO_PIN_PIN27},
+ {"pin28", BCMOLT_GPIO_PIN_PIN28},
+ {"pin29", BCMOLT_GPIO_PIN_PIN29},
+ {"pin30", BCMOLT_GPIO_PIN_PIN30},
+ {"pin31", BCMOLT_GPIO_PIN_PIN31},
+ BCMCLI_ENUM_LAST
+ };
+ static bcmcli_enum_val fpga_ext_irq_table[] =
+ {
+ {"ext_irq0", BCMOLT_EXT_IRQ_EXT_IRQ0},
+ {"ext_irq1", BCMOLT_EXT_IRQ_EXT_IRQ1},
+ {"ext_irq2", BCMOLT_EXT_IRQ_EXT_IRQ2},
+ {"ext_irq3", BCMOLT_EXT_IRQ_EXT_IRQ3},
+ {"ext_irq4", BCMOLT_EXT_IRQ_EXT_IRQ4},
+ {"ext_irq5", BCMOLT_EXT_IRQ_EXT_IRQ5},
+ BCMCLI_ENUM_LAST
+ };
+
+ static bcmcli_enum_val fpga_gpio_dir_table[] =
+ {
+ {"input", BCM_FPGA_GPIO_DIR_INPUT},
+ {"output", BCM_FPGA_GPIO_DIR_OUTPUT},
+ BCMCLI_ENUM_LAST
+ };
+
+ static bcmcli_enum_val dpll_devices[] = {
+ { .name="gpon", .val=GPON_DPLL},
+ { .name="epon", .val=EPON_DPLL},
+ { .name="synce", .val=GPON_SYNCE},
+ BCMCLI_ENUM_LAST
+ };
+
+ board_dir = bcmcli_dir_add(top_dir, "board", "Board", BCMCLI_ACCESS_GUEST, NULL);
+ BCMOS_CHECK_RETURN_ERROR(!board_dir, BCM_ERR_INTERNAL);
+
+ i2c_dir = bcmcli_dir_add(board_dir, "i2c", "i2c", BCMCLI_ACCESS_GUEST, NULL);
+ BCMOS_CHECK_RETURN_ERROR(!i2c_dir, BCM_ERR_INTERNAL);
+
+ BCMCLI_MAKE_CMD(i2c_dir, "dev_change", "Change current device", bcm_board_cli_dev_change,
+ BCMCLI_MAKE_PARM_ENUM("dev", "device", bcm_i2c_dev_addr_table, 0));
+
+ BCMCLI_MAKE_CMD(i2c_dir, "dev_write", "Write to current i2c device", bcm_board_cli_dev_write,
+ BCMCLI_MAKE_PARM("width", "Width of register in bits (8|16|32)", BCMCLI_PARM_NUMBER, 0),
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
+ BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD(i2c_dir, "dev_read", "Read from current i2c device", bcm_board_cli_dev_read,
+ BCMCLI_MAKE_PARM("width", "Width of register in bits (8|16|32)", BCMCLI_PARM_NUMBER, 0),
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD(i2c_dir, "switch_write", "Write to switch", bcm_board_cli_switch_write,
+ BCMCLI_MAKE_PARM_RANGE("val", "value", BCMCLI_PARM_HEX, 0, 0, UCHAR_MAX));
+
+ BCMCLI_MAKE_CMD_NOPARM(i2c_dir, "switch_read", "Read from switch", bcm_board_cli_switch_read);
+
+ BCMCLI_MAKE_CMD(i2c_dir, "fpga_write", "Write to FPGA", bcm_board_cli_fpga_write,
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
+ BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD(i2c_dir, "fpga_read", "Read from FPGA", bcm_board_cli_fpga_read,
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD_NOPARM(board_dir, "fpga_version", "FPGA version", bcm_board_cli_fpga_version);
+
+ BCMCLI_MAKE_CMD(board_dir, "fpga_set_gpio_dir", "Set GPIO direction", bcm_board_cli_fpga_set_gpio_dir,
+ BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0),
+ BCMCLI_MAKE_PARM_ENUM("dir", "Direction", fpga_gpio_dir_table, 0));
+ BCMCLI_MAKE_CMD(board_dir, "fpga_get_gpio_dir", "Get GPIO direction", bcm_board_cli_fpga_get_gpio_dir,
+ BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0));
+ BCMCLI_MAKE_CMD(board_dir, "fpga_write_gpio", "Write to GPIO pin", bcm_board_cli_fpga_write_gpio,
+ BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0),
+ BCMCLI_MAKE_PARM("val", "Value", BCMCLI_PARM_HEX, 0));
+ BCMCLI_MAKE_CMD(board_dir, "fpga_read_gpio", "Read from GPIO pin", bcm_board_cli_fpga_read_gpio,
+ BCMCLI_MAKE_PARM_ENUM("gpio_pin", "GPIO pin", fpga_gpio_pin_table, 0));
+ BCMCLI_MAKE_CMD(board_dir, "fpga_gen_irq", "Generate GPIO IRQ", bcm_board_cli_fpga_gen_gpio_irq,
+ BCMCLI_MAKE_PARM_ENUM("irq", "IRQ", fpga_ext_irq_table, 0));
+
+ BCMCLI_MAKE_CMD(board_dir, "trx_enable", "Enable transceiver", bcm_board_cli_trx_enable,
+ BCMCLI_MAKE_PARM("pon_id", "pon_id", BCMCLI_PARM_UDECIMAL, 0));
+
+ BCMCLI_MAKE_CMD(board_dir, "trx_disable", "Disable transceiver", bcm_board_cli_trx_disable,
+ BCMCLI_MAKE_PARM("pon_id", "pon_id", BCMCLI_PARM_UDECIMAL, 0));
+
+ BCMCLI_MAKE_CMD_NOPARM(board_dir, "device_reset", "Reset the device - clears the reset bit and then set it on", bcm_board_cli_device_reset);
+
+ BCMCLI_MAKE_CMD_NOPARM(board_dir, "device_on", "Keeps the device with reset bit on", bcm_board_cli_device_on);
+
+ BCMCLI_MAKE_CMD_NOPARM(board_dir, "device_off", "Keeps the device with reset bit off", bcm_board_cli_device_off);
+
+ BCMCLI_MAKE_CMD(board_dir, "fpga_reg_read", "Read data from an FPGA register", bcm_board_cli_fpga_reg_read,
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD(board_dir, "fpga_reg_write", "Write data to an FPGA register", bcm_board_cli_fpga_reg_write,
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
+ BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD(board_dir, "dpll", "Burn DPLL", bcm_board_cli_burn_dpll,
+ BCMCLI_MAKE_PARM_ENUM("device", "Device", dpll_devices, 0));
+
+ BCMCLI_MAKE_CMD(board_dir, "dpll_write", "Write to DPLL", bcm_board_cli_dpll_write,
+ BCMCLI_MAKE_PARM("page", "page", BCMCLI_PARM_HEX, 0),
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0),
+ BCMCLI_MAKE_PARM("val", "value", BCMCLI_PARM_HEX, 0));
+
+ BCMCLI_MAKE_CMD(board_dir, "dpll_read", "Read from DPLL", bcm_board_cli_dpll_read,
+ BCMCLI_MAKE_PARM("page", "page", BCMCLI_PARM_HEX, 0),
+ BCMCLI_MAKE_PARM("addr", "address", BCMCLI_PARM_HEX, 0));
+
+ rc = bcm_board_get_board_id(&board_id);
+ BCMOS_CHECK_RETURN(rc, rc, rc);
+ /* check if the board is SVK#3 */
+ if (board_id == SVK_3)
+ {
+ BCMCLI_MAKE_CMD_NOPARM(board_dir, "kt2_on", "Keeps the Katana2 with reset bit on", bcm_board_cli_kt2_on);
+
+ BCMCLI_MAKE_CMD_NOPARM(board_dir, "kt2_off", "Keeps the Katana2 with reset bit off", bcm_board_cli_kt2_off);
+
+ dir = bcmcli_dir_add(board_dir, "switch", "Switch", BCMCLI_ACCESS_ADMIN, NULL);
+ BCMOS_CHECK_RETURN_ERROR(!dir, BCM_ERR_NOMEM);
+ BCMCLI_MAKE_CMD(dir, "conn", "connect to switch daemon", kt2_conn,
+ BCMCLI_MAKE_PARM("port", "connection port on localhost", BCMCLI_PARM_NUMBER, 0));
+ BCMCLI_MAKE_CMD_NOPARM(dir, "disconn", "disconnect from switch daemon", kt2_disconn);
+ BCMCLI_MAKE_CMD(dir, "cmd", "command to switch - string between quotes", kt2_cmd,
+ BCMCLI_MAKE_PARM("", "", BCMCLI_PARM_STRING, 0));
+ }
+ return BCM_ERR_OK;
+}
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/bcmolt_board_cli.h b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board_cli.h
new file mode 100644
index 0000000..91a904a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/bcmolt_board_cli.h
@@ -0,0 +1,39 @@
+/*
+<: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_BOARD_CLI_H_
+#define _BCMOLT_BOARD_CLI_H_
+
+#include <bcmos_system.h>
+#include <bcmcli.h>
+
+bcmos_errno bcm_board_cli_init(bcmcli_entry *top_dir);
+
+#endif
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/bcmolt_dpll_table.h b/bcm68620_release/release/host_customized/board/wrx/bcmolt_dpll_table.h
new file mode 100755
index 0000000..a7d610e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/bcmolt_dpll_table.h
@@ -0,0 +1,1144 @@
+#ifndef _BCMOLT_DPLL_TABLE_H_
+#define _BCMOLT_DPLL_TABLE_H_
+
+/* auto generated loading files */
+
+static dpll_command gpon_dpll_table[] =
+{
+ {0x0B,0x24,0xD8},
+ {0x0B,0x25,0x00},
+ {0x00,0x0B,0x68},
+ {0x00,0x16,0x02},
+ {0x00,0x17,0x1C},
+ {0x00,0x18,0xEE},
+ {0x00,0x19,0xDD},
+ {0x00,0x1A,0xDF},
+ {0x00,0x2B,0x02},
+ {0x00,0x2C,0x01},
+ {0x00,0x2D,0x01},
+ {0x00,0x2E,0x6F},
+ {0x00,0x2F,0x00},
+ {0x00,0x30,0x00},
+ {0x00,0x31,0x00},
+ {0x00,0x32,0x00},
+ {0x00,0x33,0x00},
+ {0x00,0x34,0x00},
+ {0x00,0x35,0x00},
+ {0x00,0x36,0x6F},
+ {0x00,0x37,0x00},
+ {0x00,0x38,0x00},
+ {0x00,0x39,0x00},
+ {0x00,0x3A,0x00},
+ {0x00,0x3B,0x00},
+ {0x00,0x3C,0x00},
+ {0x00,0x3D,0x00},
+ {0x00,0x3F,0x11},
+ {0x00,0x40,0x04},
+ {0x00,0x41,0x0E},
+ {0x00,0x42,0x00},
+ {0x00,0x43,0x00},
+ {0x00,0x44,0x00},
+ {0x00,0x45,0x0C},
+ {0x00,0x46,0x32},
+ {0x00,0x47,0x00},
+ {0x00,0x48,0x00},
+ {0x00,0x49,0x00},
+ {0x00,0x4A,0x32},
+ {0x00,0x4B,0x00},
+ {0x00,0x4C,0x00},
+ {0x00,0x4D,0x00},
+ {0x00,0x4E,0x05},
+ {0x00,0x4F,0x00},
+ {0x00,0x51,0x03},
+ {0x00,0x52,0x00},
+ {0x00,0x53,0x00},
+ {0x00,0x54,0x00},
+ {0x00,0x55,0x03},
+ {0x00,0x56,0x00},
+ {0x00,0x57,0x00},
+ {0x00,0x58,0x00},
+ {0x00,0x59,0x03},
+ {0x00,0x5A,0x55},
+ {0x00,0x5B,0x55},
+ {0x00,0x5C,0xD0},
+ {0x00,0x5D,0x00},
+ {0x00,0x5E,0x00},
+ {0x00,0x5F,0x00},
+ {0x00,0x60,0x00},
+ {0x00,0x61,0x00},
+ {0x00,0x62,0x00},
+ {0x00,0x63,0x00},
+ {0x00,0x64,0x00},
+ {0x00,0x65,0x00},
+ {0x00,0x66,0x00},
+ {0x00,0x67,0x00},
+ {0x00,0x68,0x00},
+ {0x00,0x69,0x00},
+ {0x00,0x92,0x00},
+ {0x00,0x93,0x00},
+ {0x00,0x95,0x00},
+ {0x00,0x96,0x00},
+ {0x00,0x98,0x00},
+ {0x00,0x9A,0x02},
+ {0x00,0x9B,0x10},
+ {0x00,0x9D,0x00},
+ {0x00,0x9E,0x20},
+ {0x00,0xA0,0x00},
+ {0x00,0xA2,0x02},
+ {0x00,0xA8,0xC9},
+ {0x00,0xA9,0x62},
+ {0x00,0xAA,0x10},
+ {0x00,0xAB,0x00},
+ {0x00,0xAC,0x00},
+ {0x01,0x02,0x01},
+ {0x01,0x08,0x06},
+ {0x01,0x09,0x09},
+ {0x01,0x0A,0x6B},
+ {0x01,0x0B,0x00},
+ {0x01,0x0D,0x01},
+ {0x01,0x0E,0x09},
+ {0x01,0x0F,0x3B},
+ {0x01,0x10,0x00},
+ {0x01,0x12,0x06},
+ {0x01,0x13,0x09},
+ {0x01,0x14,0x6B},
+ {0x01,0x15,0x00},
+ {0x01,0x17,0x01},
+ {0x01,0x18,0x09},
+ {0x01,0x19,0x3B},
+ {0x01,0x1A,0x00},
+ {0x01,0x1C,0x06},
+ {0x01,0x1D,0x09},
+ {0x01,0x1E,0x6B},
+ {0x01,0x1F,0x00},
+ {0x01,0x21,0x01},
+ {0x01,0x22,0x09},
+ {0x01,0x23,0x3B},
+ {0x01,0x24,0x00},
+ {0x01,0x26,0x06},
+ {0x01,0x27,0x09},
+ {0x01,0x28,0x6B},
+ {0x01,0x29,0x00},
+ {0x01,0x2B,0x01},
+ {0x01,0x2C,0x09},
+ {0x01,0x2D,0x3B},
+ {0x01,0x2E,0x00},
+ {0x01,0x30,0x06},
+ {0x01,0x31,0x09},
+ {0x01,0x32,0x6B},
+ {0x01,0x33,0x00},
+ {0x01,0x3A,0x06},
+ {0x01,0x3B,0xCC},
+ {0x01,0x3C,0x00},
+ {0x01,0x3D,0x00},
+ {0x01,0x3F,0x00},
+ {0x01,0x40,0x00},
+ {0x01,0x41,0x40},
+ {0x01,0x42,0xFF},
+ {0x02,0x02,0x00},
+ {0x02,0x03,0x00},
+ {0x02,0x04,0x00},
+ {0x02,0x05,0x00},
+ {0x02,0x06,0x00},
+ {0x02,0x08,0x4F},
+ {0x02,0x09,0x00},
+ {0x02,0x0A,0x00},
+ {0x02,0x0B,0x00},
+ {0x02,0x0C,0x00},
+ {0x02,0x0D,0x00},
+ {0x02,0x0E,0x01},
+ {0x02,0x0F,0x00},
+ {0x02,0x10,0x00},
+ {0x02,0x11,0x00},
+ {0x02,0x12,0x00},
+ {0x02,0x13,0x00},
+ {0x02,0x14,0x00},
+ {0x02,0x15,0x00},
+ {0x02,0x16,0x00},
+ {0x02,0x17,0x00},
+ {0x02,0x18,0x00},
+ {0x02,0x19,0x00},
+ {0x02,0x1A,0x00},
+ {0x02,0x1B,0x00},
+ {0x02,0x1C,0x00},
+ {0x02,0x1D,0x00},
+ {0x02,0x1E,0x00},
+ {0x02,0x1F,0x00},
+ {0x02,0x20,0x00},
+ {0x02,0x21,0x00},
+ {0x02,0x22,0x00},
+ {0x02,0x23,0x00},
+ {0x02,0x24,0x00},
+ {0x02,0x25,0x00},
+ {0x02,0x26,0x00},
+ {0x02,0x27,0x00},
+ {0x02,0x28,0x00},
+ {0x02,0x29,0x00},
+ {0x02,0x2A,0x00},
+ {0x02,0x2B,0x00},
+ {0x02,0x2C,0x00},
+ {0x02,0x2D,0x00},
+ {0x02,0x2E,0x00},
+ {0x02,0x2F,0x00},
+ {0x02,0x31,0x03},
+ {0x02,0x32,0x03},
+ {0x02,0x33,0x03},
+ {0x02,0x34,0x03},
+ {0x02,0x35,0x00},
+ {0x02,0x36,0x00},
+ {0x02,0x37,0x00},
+ {0x02,0x38,0xC0},
+ {0x02,0x39,0xDE},
+ {0x02,0x3A,0x00},
+ {0x02,0x3B,0x00},
+ {0x02,0x3C,0x00},
+ {0x02,0x3D,0x00},
+ {0x02,0x3E,0xC8},
+ {0x02,0x4A,0x00},
+ {0x02,0x4B,0x00},
+ {0x02,0x4C,0x00},
+ {0x02,0x4D,0x00},
+ {0x02,0x4E,0x00},
+ {0x02,0x4F,0x00},
+ {0x02,0x50,0x00},
+ {0x02,0x51,0x00},
+ {0x02,0x52,0x00},
+ {0x02,0x53,0x00},
+ {0x02,0x54,0x00},
+ {0x02,0x55,0x00},
+ {0x02,0x56,0x00},
+ {0x02,0x57,0x00},
+ {0x02,0x58,0x00},
+ {0x02,0x59,0x00},
+ {0x02,0x5A,0x00},
+ {0x02,0x5B,0x00},
+ {0x02,0x5C,0x00},
+ {0x02,0x5D,0x00},
+ {0x02,0x5E,0x00},
+ {0x02,0x5F,0x00},
+ {0x02,0x60,0x00},
+ {0x02,0x61,0x00},
+ {0x02,0x62,0x00},
+ {0x02,0x63,0x00},
+ {0x02,0x64,0x00},
+ {0x02,0x68,0x00},
+ {0x02,0x69,0x00},
+ {0x02,0x6A,0x00},
+ {0x02,0x6B,0x47},
+ {0x02,0x6C,0x50},
+ {0x02,0x6D,0x4F},
+ {0x02,0x6E,0x4E},
+ {0x02,0x6F,0x5F},
+ {0x02,0x70,0x43},
+ {0x02,0x71,0x4C},
+ {0x02,0x72,0x4B},
+ {0x03,0x02,0x00},
+ {0x03,0x03,0x00},
+ {0x03,0x04,0x00},
+ {0x03,0x05,0x00},
+ {0x03,0x06,0x16},
+ {0x03,0x07,0x00},
+ {0x03,0x08,0x00},
+ {0x03,0x09,0x00},
+ {0x03,0x0A,0x00},
+ {0x03,0x0B,0x80},
+ {0x03,0x0D,0x00},
+ {0x03,0x0E,0x00},
+ {0x03,0x0F,0x00},
+ {0x03,0x10,0x00},
+ {0x03,0x11,0x00},
+ {0x03,0x12,0x00},
+ {0x03,0x13,0x00},
+ {0x03,0x14,0x00},
+ {0x03,0x15,0x00},
+ {0x03,0x16,0x00},
+ {0x03,0x18,0x00},
+ {0x03,0x19,0x00},
+ {0x03,0x1A,0x00},
+ {0x03,0x1B,0x00},
+ {0x03,0x1C,0x00},
+ {0x03,0x1D,0x00},
+ {0x03,0x1E,0x00},
+ {0x03,0x1F,0x00},
+ {0x03,0x20,0x00},
+ {0x03,0x21,0x00},
+ {0x03,0x23,0x00},
+ {0x03,0x24,0x00},
+ {0x03,0x25,0x00},
+ {0x03,0x26,0x00},
+ {0x03,0x27,0x00},
+ {0x03,0x28,0x00},
+ {0x03,0x29,0x00},
+ {0x03,0x2A,0x00},
+ {0x03,0x2B,0x00},
+ {0x03,0x2C,0x00},
+ {0x03,0x2E,0x00},
+ {0x03,0x2F,0x00},
+ {0x03,0x30,0x00},
+ {0x03,0x31,0x00},
+ {0x03,0x32,0x00},
+ {0x03,0x33,0x00},
+ {0x03,0x34,0x00},
+ {0x03,0x35,0x00},
+ {0x03,0x36,0x00},
+ {0x03,0x37,0x00},
+ {0x03,0x39,0x1F},
+ {0x03,0x3B,0x00},
+ {0x03,0x3C,0x00},
+ {0x03,0x3D,0x00},
+ {0x03,0x3E,0x00},
+ {0x03,0x3F,0x00},
+ {0x03,0x40,0x00},
+ {0x03,0x41,0x00},
+ {0x03,0x42,0x00},
+ {0x03,0x43,0x00},
+ {0x03,0x44,0x00},
+ {0x03,0x45,0x00},
+ {0x03,0x46,0x00},
+ {0x03,0x47,0x00},
+ {0x03,0x48,0x00},
+ {0x03,0x49,0x00},
+ {0x03,0x4A,0x00},
+ {0x03,0x4B,0x00},
+ {0x03,0x4C,0x00},
+ {0x03,0x4D,0x00},
+ {0x03,0x4E,0x00},
+ {0x03,0x4F,0x00},
+ {0x03,0x50,0x00},
+ {0x03,0x51,0x00},
+ {0x03,0x52,0x00},
+ {0x03,0x53,0x00},
+ {0x03,0x54,0x00},
+ {0x03,0x55,0x00},
+ {0x03,0x56,0x00},
+ {0x03,0x57,0x00},
+ {0x03,0x58,0x00},
+ {0x03,0x59,0x00},
+ {0x03,0x5A,0x00},
+ {0x03,0x5B,0x00},
+ {0x03,0x5C,0x00},
+ {0x03,0x5D,0x00},
+ {0x03,0x5E,0x00},
+ {0x03,0x5F,0x00},
+ {0x03,0x60,0x00},
+ {0x03,0x61,0x00},
+ {0x03,0x62,0x00},
+ {0x04,0x87,0x00},
+ {0x05,0x02,0x01},
+ {0x05,0x08,0x14},
+ {0x05,0x09,0x22},
+ {0x05,0x0A,0x0D},
+ {0x05,0x0B,0x0C},
+ {0x05,0x0C,0x01},
+ {0x05,0x0D,0x3F},
+ {0x05,0x0E,0x15},
+ {0x05,0x0F,0x26},
+ {0x05,0x10,0x0C},
+ {0x05,0x11,0x0B},
+ {0x05,0x12,0x01},
+ {0x05,0x13,0x3F},
+ {0x05,0x15,0x00},
+ {0x05,0x16,0x00},
+ {0x05,0x17,0x00},
+ {0x05,0x18,0xDF},
+ {0x05,0x19,0x38},
+ {0x05,0x1A,0x03},
+ {0x05,0x1B,0x00},
+ {0x05,0x1C,0x00},
+ {0x05,0x1D,0x80},
+ {0x05,0x1E,0x96},
+ {0x05,0x1F,0x98},
+ {0x05,0x21,0x33},
+ {0x05,0x2A,0x01},
+ {0x05,0x2B,0x01},
+ {0x05,0x2C,0x0F},
+ {0x05,0x2D,0x03},
+ {0x05,0x2E,0x19},
+ {0x05,0x2F,0x19},
+ {0x05,0x31,0x00},
+ {0x05,0x32,0x4B},
+ {0x05,0x33,0x03},
+ {0x05,0x34,0x00},
+ {0x05,0x36,0x0C},
+ {0x05,0x37,0x00},
+ {0x05,0x38,0x01},
+ {0x05,0x39,0x00},
+ {0x09,0x0E,0x02},
+ {0x09,0x43,0x01},
+ {0x09,0x49,0x01},
+ {0x09,0x4A,0x01},
+ {0x0A,0x02,0x00},
+ {0x0A,0x03,0x01},
+ {0x0A,0x04,0x01},
+ {0x0A,0x05,0x01},
+ {0x0B,0x44,0x0F},
+ {0x0B,0x46,0x00},
+ {0x0B,0x47,0x00},
+ {0x0B,0x48,0x0E},
+ {0x0B,0x4A,0x1E},
+ {0x05,0x14,0x01},
+ {0x00,0x1C,0x01},
+ {0x0B,0x24,0xDB},
+ {0x0B,0x25,0x02}
+};
+
+static dpll_command epon_dpll_table[] =
+{
+ {0x0B,0x24,0xD8},
+ {0x0B,0x25,0x00},
+ {0x00,0x0B,0x68},
+ {0x00,0x16,0x02},
+ {0x00,0x17,0x1C},
+ {0x00,0x18,0xEE},
+ {0x00,0x19,0xDD},
+ {0x00,0x1A,0xDF},
+ {0x00,0x2B,0x02},
+ {0x00,0x2C,0x01},
+ {0x00,0x2D,0x01},
+ {0x00,0x2E,0x70},
+ {0x00,0x2F,0x00},
+ {0x00,0x30,0x00},
+ {0x00,0x31,0x00},
+ {0x00,0x32,0x00},
+ {0x00,0x33,0x00},
+ {0x00,0x34,0x00},
+ {0x00,0x35,0x00},
+ {0x00,0x36,0x70},
+ {0x00,0x37,0x00},
+ {0x00,0x38,0x00},
+ {0x00,0x39,0x00},
+ {0x00,0x3A,0x00},
+ {0x00,0x3B,0x00},
+ {0x00,0x3C,0x00},
+ {0x00,0x3D,0x00},
+ {0x00,0x3F,0x11},
+ {0x00,0x40,0x04},
+ {0x00,0x41,0x0E},
+ {0x00,0x42,0x00},
+ {0x00,0x43,0x00},
+ {0x00,0x44,0x00},
+ {0x00,0x45,0x0C},
+ {0x00,0x46,0x32},
+ {0x00,0x47,0x00},
+ {0x00,0x48,0x00},
+ {0x00,0x49,0x00},
+ {0x00,0x4A,0x32},
+ {0x00,0x4B,0x00},
+ {0x00,0x4C,0x00},
+ {0x00,0x4D,0x00},
+ {0x00,0x4E,0x05},
+ {0x00,0x4F,0x00},
+ {0x00,0x51,0x03},
+ {0x00,0x52,0x00},
+ {0x00,0x53,0x00},
+ {0x00,0x54,0x00},
+ {0x00,0x55,0x03},
+ {0x00,0x56,0x00},
+ {0x00,0x57,0x00},
+ {0x00,0x58,0x00},
+ {0x00,0x59,0x03},
+ {0x00,0x5A,0x55},
+ {0x00,0x5B,0x55},
+ {0x00,0x5C,0xD0},
+ {0x00,0x5D,0x00},
+ {0x00,0x5E,0x00},
+ {0x00,0x5F,0x00},
+ {0x00,0x60,0x00},
+ {0x00,0x61,0x00},
+ {0x00,0x62,0x00},
+ {0x00,0x63,0x00},
+ {0x00,0x64,0x00},
+ {0x00,0x65,0x00},
+ {0x00,0x66,0x00},
+ {0x00,0x67,0x00},
+ {0x00,0x68,0x00},
+ {0x00,0x69,0x00},
+ {0x00,0x92,0x00},
+ {0x00,0x93,0x00},
+ {0x00,0x95,0x00},
+ {0x00,0x96,0x00},
+ {0x00,0x98,0x00},
+ {0x00,0x9A,0x02},
+ {0x00,0x9B,0x10},
+ {0x00,0x9D,0x00},
+ {0x00,0x9E,0x20},
+ {0x00,0xA0,0x00},
+ {0x00,0xA2,0x02},
+ {0x00,0xA8,0x1E},
+ {0x00,0xA9,0x94},
+ {0x00,0xAA,0x10},
+ {0x00,0xAB,0x00},
+ {0x00,0xAC,0x00},
+ {0x01,0x02,0x01},
+ {0x01,0x08,0x06},
+ {0x01,0x09,0x09},
+ {0x01,0x0A,0x6B},
+ {0x01,0x0B,0x00},
+ {0x01,0x0D,0x01},
+ {0x01,0x0E,0x09},
+ {0x01,0x0F,0x3B},
+ {0x01,0x10,0x00},
+ {0x01,0x12,0x06},
+ {0x01,0x13,0x09},
+ {0x01,0x14,0x6B},
+ {0x01,0x15,0x00},
+ {0x01,0x17,0x01},
+ {0x01,0x18,0x09},
+ {0x01,0x19,0x3B},
+ {0x01,0x1A,0x00},
+ {0x01,0x1C,0x06},
+ {0x01,0x1D,0x09},
+ {0x01,0x1E,0x6B},
+ {0x01,0x1F,0x00},
+ {0x01,0x21,0x01},
+ {0x01,0x22,0x09},
+ {0x01,0x23,0x3B},
+ {0x01,0x24,0x00},
+ {0x01,0x26,0x06},
+ {0x01,0x27,0x09},
+ {0x01,0x28,0x6B},
+ {0x01,0x29,0x00},
+ {0x01,0x2B,0x01},
+ {0x01,0x2C,0x09},
+ {0x01,0x2D,0x3B},
+ {0x01,0x2E,0x00},
+ {0x01,0x30,0x06},
+ {0x01,0x31,0x09},
+ {0x01,0x32,0x6B},
+ {0x01,0x33,0x00},
+ {0x01,0x3A,0x06},
+ {0x01,0x3B,0xCC},
+ {0x01,0x3C,0x00},
+ {0x01,0x3D,0x00},
+ {0x01,0x3F,0x00},
+ {0x01,0x40,0x00},
+ {0x01,0x41,0x40},
+ {0x01,0x42,0xFF},
+ {0x02,0x02,0x00},
+ {0x02,0x03,0x00},
+ {0x02,0x04,0x00},
+ {0x02,0x05,0x00},
+ {0x02,0x06,0x00},
+ {0x02,0x08,0x4F},
+ {0x02,0x09,0x00},
+ {0x02,0x0A,0x00},
+ {0x02,0x0B,0x00},
+ {0x02,0x0C,0x00},
+ {0x02,0x0D,0x00},
+ {0x02,0x0E,0x01},
+ {0x02,0x0F,0x00},
+ {0x02,0x10,0x00},
+ {0x02,0x11,0x00},
+ {0x02,0x12,0x00},
+ {0x02,0x13,0x00},
+ {0x02,0x14,0x00},
+ {0x02,0x15,0x00},
+ {0x02,0x16,0x00},
+ {0x02,0x17,0x00},
+ {0x02,0x18,0x00},
+ {0x02,0x19,0x00},
+ {0x02,0x1A,0x00},
+ {0x02,0x1B,0x00},
+ {0x02,0x1C,0x00},
+ {0x02,0x1D,0x00},
+ {0x02,0x1E,0x00},
+ {0x02,0x1F,0x00},
+ {0x02,0x20,0x00},
+ {0x02,0x21,0x00},
+ {0x02,0x22,0x00},
+ {0x02,0x23,0x00},
+ {0x02,0x24,0x00},
+ {0x02,0x25,0x00},
+ {0x02,0x26,0x00},
+ {0x02,0x27,0x00},
+ {0x02,0x28,0x00},
+ {0x02,0x29,0x00},
+ {0x02,0x2A,0x00},
+ {0x02,0x2B,0x00},
+ {0x02,0x2C,0x00},
+ {0x02,0x2D,0x00},
+ {0x02,0x2E,0x00},
+ {0x02,0x2F,0x00},
+ {0x02,0x31,0x03},
+ {0x02,0x32,0x03},
+ {0x02,0x33,0x03},
+ {0x02,0x34,0x03},
+ {0x02,0x35,0x00},
+ {0x02,0x36,0x00},
+ {0x02,0x37,0x00},
+ {0x02,0x38,0xD8},
+ {0x02,0x39,0xD6},
+ {0x02,0x3A,0x00},
+ {0x02,0x3B,0x00},
+ {0x02,0x3C,0x00},
+ {0x02,0x3D,0x00},
+ {0x02,0x3E,0xC0},
+ {0x02,0x4A,0x00},
+ {0x02,0x4B,0x00},
+ {0x02,0x4C,0x00},
+ {0x02,0x4D,0x00},
+ {0x02,0x4E,0x00},
+ {0x02,0x4F,0x00},
+ {0x02,0x50,0x00},
+ {0x02,0x51,0x00},
+ {0x02,0x52,0x00},
+ {0x02,0x53,0x00},
+ {0x02,0x54,0x00},
+ {0x02,0x55,0x00},
+ {0x02,0x56,0x00},
+ {0x02,0x57,0x00},
+ {0x02,0x58,0x00},
+ {0x02,0x59,0x00},
+ {0x02,0x5A,0x00},
+ {0x02,0x5B,0x00},
+ {0x02,0x5C,0x00},
+ {0x02,0x5D,0x00},
+ {0x02,0x5E,0x00},
+ {0x02,0x5F,0x00},
+ {0x02,0x60,0x00},
+ {0x02,0x61,0x00},
+ {0x02,0x62,0x00},
+ {0x02,0x63,0x00},
+ {0x02,0x64,0x00},
+ {0x02,0x68,0x00},
+ {0x02,0x69,0x00},
+ {0x02,0x6A,0x00},
+ {0x02,0x6B,0x45},
+ {0x02,0x6C,0x50},
+ {0x02,0x6D,0x4F},
+ {0x02,0x6E,0x4E},
+ {0x02,0x6F,0x5F},
+ {0x02,0x70,0x43},
+ {0x02,0x71,0x4C},
+ {0x02,0x72,0x4B},
+ {0x03,0x02,0x00},
+ {0x03,0x03,0x00},
+ {0x03,0x04,0x00},
+ {0x03,0x05,0x00},
+ {0x03,0x06,0x16},
+ {0x03,0x07,0x00},
+ {0x03,0x08,0x00},
+ {0x03,0x09,0x00},
+ {0x03,0x0A,0x00},
+ {0x03,0x0B,0x80},
+ {0x03,0x0D,0x00},
+ {0x03,0x0E,0x00},
+ {0x03,0x0F,0x00},
+ {0x03,0x10,0x00},
+ {0x03,0x11,0x00},
+ {0x03,0x12,0x00},
+ {0x03,0x13,0x00},
+ {0x03,0x14,0x00},
+ {0x03,0x15,0x00},
+ {0x03,0x16,0x00},
+ {0x03,0x18,0x00},
+ {0x03,0x19,0x00},
+ {0x03,0x1A,0x00},
+ {0x03,0x1B,0x00},
+ {0x03,0x1C,0x00},
+ {0x03,0x1D,0x00},
+ {0x03,0x1E,0x00},
+ {0x03,0x1F,0x00},
+ {0x03,0x20,0x00},
+ {0x03,0x21,0x00},
+ {0x03,0x23,0x00},
+ {0x03,0x24,0x00},
+ {0x03,0x25,0x00},
+ {0x03,0x26,0x00},
+ {0x03,0x27,0x00},
+ {0x03,0x28,0x00},
+ {0x03,0x29,0x00},
+ {0x03,0x2A,0x00},
+ {0x03,0x2B,0x00},
+ {0x03,0x2C,0x00},
+ {0x03,0x2E,0x00},
+ {0x03,0x2F,0x00},
+ {0x03,0x30,0x00},
+ {0x03,0x31,0x00},
+ {0x03,0x32,0x00},
+ {0x03,0x33,0x00},
+ {0x03,0x34,0x00},
+ {0x03,0x35,0x00},
+ {0x03,0x36,0x00},
+ {0x03,0x37,0x00},
+ {0x03,0x39,0x1F},
+ {0x03,0x3B,0x00},
+ {0x03,0x3C,0x00},
+ {0x03,0x3D,0x00},
+ {0x03,0x3E,0x00},
+ {0x03,0x3F,0x00},
+ {0x03,0x40,0x00},
+ {0x03,0x41,0x00},
+ {0x03,0x42,0x00},
+ {0x03,0x43,0x00},
+ {0x03,0x44,0x00},
+ {0x03,0x45,0x00},
+ {0x03,0x46,0x00},
+ {0x03,0x47,0x00},
+ {0x03,0x48,0x00},
+ {0x03,0x49,0x00},
+ {0x03,0x4A,0x00},
+ {0x03,0x4B,0x00},
+ {0x03,0x4C,0x00},
+ {0x03,0x4D,0x00},
+ {0x03,0x4E,0x00},
+ {0x03,0x4F,0x00},
+ {0x03,0x50,0x00},
+ {0x03,0x51,0x00},
+ {0x03,0x52,0x00},
+ {0x03,0x53,0x00},
+ {0x03,0x54,0x00},
+ {0x03,0x55,0x00},
+ {0x03,0x56,0x00},
+ {0x03,0x57,0x00},
+ {0x03,0x58,0x00},
+ {0x03,0x59,0x00},
+ {0x03,0x5A,0x00},
+ {0x03,0x5B,0x00},
+ {0x03,0x5C,0x00},
+ {0x03,0x5D,0x00},
+ {0x03,0x5E,0x00},
+ {0x03,0x5F,0x00},
+ {0x03,0x60,0x00},
+ {0x03,0x61,0x00},
+ {0x03,0x62,0x00},
+ {0x04,0x87,0x00},
+ {0x05,0x02,0x01},
+ {0x05,0x08,0x14},
+ {0x05,0x09,0x22},
+ {0x05,0x0A,0x0D},
+ {0x05,0x0B,0x0C},
+ {0x05,0x0C,0x01},
+ {0x05,0x0D,0x3F},
+ {0x05,0x0E,0x15},
+ {0x05,0x0F,0x26},
+ {0x05,0x10,0x0C},
+ {0x05,0x11,0x0B},
+ {0x05,0x12,0x01},
+ {0x05,0x13,0x3F},
+ {0x05,0x15,0x00},
+ {0x05,0x16,0x00},
+ {0x05,0x17,0x00},
+ {0x05,0x18,0x00},
+ {0x05,0x19,0x65},
+ {0x05,0x1A,0x03},
+ {0x05,0x1B,0x00},
+ {0x05,0x1C,0x00},
+ {0x05,0x1D,0x00},
+ {0x05,0x1E,0x00},
+ {0x05,0x1F,0xA0},
+ {0x05,0x21,0x33},
+ {0x05,0x2A,0x01},
+ {0x05,0x2B,0x01},
+ {0x05,0x2C,0x0F},
+ {0x05,0x2D,0x03},
+ {0x05,0x2E,0x19},
+ {0x05,0x2F,0x19},
+ {0x05,0x31,0x00},
+ {0x05,0x32,0x4B},
+ {0x05,0x33,0x03},
+ {0x05,0x34,0x00},
+ {0x05,0x36,0x0C},
+ {0x05,0x37,0x00},
+ {0x05,0x38,0x01},
+ {0x05,0x39,0x00},
+ {0x09,0x0E,0x02},
+ {0x09,0x43,0x01},
+ {0x09,0x49,0x01},
+ {0x09,0x4A,0x01},
+ {0x0A,0x02,0x00},
+ {0x0A,0x03,0x01},
+ {0x0A,0x04,0x01},
+ {0x0A,0x05,0x01},
+ {0x0B,0x44,0x0F},
+ {0x0B,0x46,0x00},
+ {0x0B,0x47,0x00},
+ {0x0B,0x48,0x0E},
+ {0x0B,0x4A,0x1E},
+ {0x05,0x14,0x01},
+ {0x00,0x1C,0x01},
+ {0x0B,0x24,0xDB},
+ {0x0B,0x25,0x02}
+};
+
+static dpll_command gpon_synce_dpll_table[] =
+{
+ {0x0B,0x24,0xD8},
+ {0x0B,0x25,0x00},
+ {0x00,0x0B,0x68},
+ {0x00,0x16,0x02},
+ {0x00,0x17,0x1C},
+ {0x00,0x18,0xCC},
+ {0x00,0x19,0xDD},
+ {0x00,0x1A,0xDF},
+ {0x00,0x2B,0x02},
+ {0x00,0x2C,0x03},
+ {0x00,0x2D,0x05},
+ {0x00,0x2E,0x6E},
+ {0x00,0x2F,0x00},
+ {0x00,0x30,0x37},
+ {0x00,0x31,0x00},
+ {0x00,0x32,0x00},
+ {0x00,0x33,0x00},
+ {0x00,0x34,0x00},
+ {0x00,0x35,0x00},
+ {0x00,0x36,0x6E},
+ {0x00,0x37,0x00},
+ {0x00,0x38,0x37},
+ {0x00,0x39,0x00},
+ {0x00,0x3A,0x00},
+ {0x00,0x3B,0x00},
+ {0x00,0x3C,0x00},
+ {0x00,0x3D,0x00},
+ {0x00,0x3F,0x33},
+ {0x00,0x40,0x04},
+ {0x00,0x41,0x0E},
+ {0x00,0x42,0x0A},
+ {0x00,0x43,0x00},
+ {0x00,0x44,0x00},
+ {0x00,0x45,0x0C},
+ {0x00,0x46,0x32},
+ {0x00,0x47,0x32},
+ {0x00,0x48,0x00},
+ {0x00,0x49,0x00},
+ {0x00,0x4A,0x32},
+ {0x00,0x4B,0x32},
+ {0x00,0x4C,0x00},
+ {0x00,0x4D,0x00},
+ {0x00,0x4E,0x55},
+ {0x00,0x4F,0x00},
+ {0x00,0x51,0x03},
+ {0x00,0x52,0x03},
+ {0x00,0x53,0x00},
+ {0x00,0x54,0x00},
+ {0x00,0x55,0x03},
+ {0x00,0x56,0x03},
+ {0x00,0x57,0x00},
+ {0x00,0x58,0x00},
+ {0x00,0x59,0x0F},
+ {0x00,0x5A,0x55},
+ {0x00,0x5B,0x55},
+ {0x00,0x5C,0xD0},
+ {0x00,0x5D,0x00},
+ {0x00,0x5E,0x55},
+ {0x00,0x5F,0x55},
+ {0x00,0x60,0xD5},
+ {0x00,0x61,0x00},
+ {0x00,0x62,0x00},
+ {0x00,0x63,0x00},
+ {0x00,0x64,0x00},
+ {0x00,0x65,0x00},
+ {0x00,0x66,0x00},
+ {0x00,0x67,0x00},
+ {0x00,0x68,0x00},
+ {0x00,0x69,0x00},
+ {0x00,0x92,0x00},
+ {0x00,0x93,0x00},
+ {0x00,0x95,0x00},
+ {0x00,0x96,0x00},
+ {0x00,0x98,0x00},
+ {0x00,0x9A,0x02},
+ {0x00,0x9B,0x00},
+ {0x00,0x9D,0x00},
+ {0x00,0x9E,0x60},
+ {0x00,0xA0,0x40},
+ {0x00,0xA2,0x02},
+ {0x00,0xA8,0xB7},
+ {0x00,0xA9,0x28},
+ {0x00,0xAA,0x10},
+ {0x00,0xAB,0x00},
+ {0x00,0xAC,0x00},
+ {0x01,0x02,0x01},
+ {0x01,0x08,0x06},
+ {0x01,0x09,0x09},
+ {0x01,0x0A,0x6B},
+ {0x01,0x0B,0x00},
+ {0x01,0x0D,0x01},
+ {0x01,0x0E,0x09},
+ {0x01,0x0F,0x3B},
+ {0x01,0x10,0x00},
+ {0x01,0x12,0x06},
+ {0x01,0x13,0x09},
+ {0x01,0x14,0x6B},
+ {0x01,0x15,0x00},
+ {0x01,0x17,0x01},
+ {0x01,0x18,0x09},
+ {0x01,0x19,0x3B},
+ {0x01,0x1A,0x00},
+ {0x01,0x1C,0x06},
+ {0x01,0x1D,0x09},
+ {0x01,0x1E,0x6B},
+ {0x01,0x1F,0x00},
+ {0x01,0x21,0x01},
+ {0x01,0x22,0x09},
+ {0x01,0x23,0x3B},
+ {0x01,0x24,0x00},
+ {0x01,0x26,0x06},
+ {0x01,0x27,0x09},
+ {0x01,0x28,0x6B},
+ {0x01,0x29,0x00},
+ {0x01,0x2B,0x01},
+ {0x01,0x2C,0x09},
+ {0x01,0x2D,0x3B},
+ {0x01,0x2E,0x00},
+ {0x01,0x30,0x06},
+ {0x01,0x31,0x09},
+ {0x01,0x32,0x6B},
+ {0x01,0x33,0x00},
+ {0x01,0x3A,0x06},
+ {0x01,0x3B,0xCC},
+ {0x01,0x3C,0x00},
+ {0x01,0x3D,0x00},
+ {0x01,0x3F,0x00},
+ {0x01,0x40,0x00},
+ {0x01,0x41,0x40},
+ {0x01,0x42,0xFF},
+ {0x02,0x02,0x00},
+ {0x02,0x03,0x00},
+ {0x02,0x04,0x00},
+ {0x02,0x05,0x00},
+ {0x02,0x06,0x00},
+ {0x02,0x08,0xDB},
+ {0x02,0x09,0x1A},
+ {0x02,0x0A,0x00},
+ {0x02,0x0B,0xC4},
+ {0x02,0x0C,0x09},
+ {0x02,0x0D,0x00},
+ {0x02,0x0E,0x00},
+ {0x02,0x0F,0x00},
+ {0x02,0x10,0x00},
+ {0x02,0x11,0x20},
+ {0x02,0x12,0x37},
+ {0x02,0x13,0x00},
+ {0x02,0x14,0x00},
+ {0x02,0x15,0x14},
+ {0x02,0x16,0x00},
+ {0x02,0x17,0x00},
+ {0x02,0x18,0x00},
+ {0x02,0x19,0x00},
+ {0x02,0x1A,0x00},
+ {0x02,0x1B,0x04},
+ {0x02,0x1C,0x00},
+ {0x02,0x1D,0x00},
+ {0x02,0x1E,0x00},
+ {0x02,0x1F,0x00},
+ {0x02,0x20,0x00},
+ {0x02,0x21,0x00},
+ {0x02,0x22,0x00},
+ {0x02,0x23,0x00},
+ {0x02,0x24,0x00},
+ {0x02,0x25,0x00},
+ {0x02,0x26,0x00},
+ {0x02,0x27,0x00},
+ {0x02,0x28,0x00},
+ {0x02,0x29,0x00},
+ {0x02,0x2A,0x00},
+ {0x02,0x2B,0x00},
+ {0x02,0x2C,0x00},
+ {0x02,0x2D,0x00},
+ {0x02,0x2E,0x00},
+ {0x02,0x2F,0x00},
+ {0x02,0x31,0x11},
+ {0x02,0x32,0x11},
+ {0x02,0x33,0x01},
+ {0x02,0x34,0x01},
+ {0x02,0x35,0x00},
+ {0x02,0x36,0x00},
+ {0x02,0x37,0x00},
+ {0x02,0x38,0xC0},
+ {0x02,0x39,0xDE},
+ {0x02,0x3A,0x00},
+ {0x02,0x3B,0x00},
+ {0x02,0x3C,0x00},
+ {0x02,0x3D,0x00},
+ {0x02,0x3E,0xC8},
+ {0x02,0x4A,0x00},
+ {0x02,0x4B,0x00},
+ {0x02,0x4C,0x00},
+ {0x02,0x4D,0x00},
+ {0x02,0x4E,0x00},
+ {0x02,0x4F,0x00},
+ {0x02,0x50,0x00},
+ {0x02,0x51,0x00},
+ {0x02,0x52,0x00},
+ {0x02,0x53,0x00},
+ {0x02,0x54,0x00},
+ {0x02,0x55,0x00},
+ {0x02,0x56,0x00},
+ {0x02,0x57,0x00},
+ {0x02,0x58,0x00},
+ {0x02,0x59,0x00},
+ {0x02,0x5A,0x00},
+ {0x02,0x5B,0x00},
+ {0x02,0x5C,0x00},
+ {0x02,0x5D,0x00},
+ {0x02,0x5E,0x00},
+ {0x02,0x5F,0x00},
+ {0x02,0x60,0x00},
+ {0x02,0x61,0x00},
+ {0x02,0x62,0x00},
+ {0x02,0x63,0x00},
+ {0x02,0x64,0x00},
+ {0x02,0x68,0x00},
+ {0x02,0x69,0x00},
+ {0x02,0x6A,0x00},
+ {0x02,0x6B,0x47},
+ {0x02,0x6C,0x50},
+ {0x02,0x6D,0x4F},
+ {0x02,0x6E,0x4E},
+ {0x02,0x6F,0x5F},
+ {0x02,0x70,0x43},
+ {0x02,0x71,0x4C},
+ {0x02,0x72,0x4B},
+ {0x03,0x02,0x00},
+ {0x03,0x03,0x00},
+ {0x03,0x04,0x00},
+ {0x03,0x05,0x00},
+ {0x03,0x06,0x16},
+ {0x03,0x07,0x00},
+ {0x03,0x08,0x00},
+ {0x03,0x09,0x00},
+ {0x03,0x0A,0x00},
+ {0x03,0x0B,0x80},
+ {0x03,0x0D,0x00},
+ {0x03,0x0E,0x00},
+ {0x03,0x0F,0x00},
+ {0x03,0x10,0x00},
+ {0x03,0x11,0x00},
+ {0x03,0x12,0x00},
+ {0x03,0x13,0x00},
+ {0x03,0x14,0x00},
+ {0x03,0x15,0x00},
+ {0x03,0x16,0x00},
+ {0x03,0x18,0x00},
+ {0x03,0x19,0x00},
+ {0x03,0x1A,0x00},
+ {0x03,0x1B,0x00},
+ {0x03,0x1C,0x00},
+ {0x03,0x1D,0x00},
+ {0x03,0x1E,0x00},
+ {0x03,0x1F,0x00},
+ {0x03,0x20,0x00},
+ {0x03,0x21,0x00},
+ {0x03,0x23,0x00},
+ {0x03,0x24,0x00},
+ {0x03,0x25,0x00},
+ {0x03,0x26,0x00},
+ {0x03,0x27,0x00},
+ {0x03,0x28,0x00},
+ {0x03,0x29,0x00},
+ {0x03,0x2A,0x00},
+ {0x03,0x2B,0x00},
+ {0x03,0x2C,0x00},
+ {0x03,0x2E,0x00},
+ {0x03,0x2F,0x00},
+ {0x03,0x30,0x00},
+ {0x03,0x31,0x00},
+ {0x03,0x32,0x00},
+ {0x03,0x33,0x00},
+ {0x03,0x34,0x00},
+ {0x03,0x35,0x00},
+ {0x03,0x36,0x00},
+ {0x03,0x37,0x00},
+ {0x03,0x39,0x1F},
+ {0x03,0x3B,0x00},
+ {0x03,0x3C,0x00},
+ {0x03,0x3D,0x00},
+ {0x03,0x3E,0x00},
+ {0x03,0x3F,0x00},
+ {0x03,0x40,0x00},
+ {0x03,0x41,0x00},
+ {0x03,0x42,0x00},
+ {0x03,0x43,0x00},
+ {0x03,0x44,0x00},
+ {0x03,0x45,0x00},
+ {0x03,0x46,0x00},
+ {0x03,0x47,0x00},
+ {0x03,0x48,0x00},
+ {0x03,0x49,0x00},
+ {0x03,0x4A,0x00},
+ {0x03,0x4B,0x00},
+ {0x03,0x4C,0x00},
+ {0x03,0x4D,0x00},
+ {0x03,0x4E,0x00},
+ {0x03,0x4F,0x00},
+ {0x03,0x50,0x00},
+ {0x03,0x51,0x00},
+ {0x03,0x52,0x00},
+ {0x03,0x53,0x00},
+ {0x03,0x54,0x00},
+ {0x03,0x55,0x00},
+ {0x03,0x56,0x00},
+ {0x03,0x57,0x00},
+ {0x03,0x58,0x00},
+ {0x03,0x59,0x00},
+ {0x03,0x5A,0x00},
+ {0x03,0x5B,0x00},
+ {0x03,0x5C,0x00},
+ {0x03,0x5D,0x00},
+ {0x03,0x5E,0x00},
+ {0x03,0x5F,0x00},
+ {0x03,0x60,0x00},
+ {0x03,0x61,0x00},
+ {0x03,0x62,0x00},
+ {0x04,0x87,0x00},
+ {0x05,0x02,0x01},
+ {0x05,0x08,0x14},
+ {0x05,0x09,0x22},
+ {0x05,0x0A,0x0D},
+ {0x05,0x0B,0x0C},
+ {0x05,0x0C,0x01},
+ {0x05,0x0D,0x3F},
+ {0x05,0x0E,0x15},
+ {0x05,0x0F,0x26},
+ {0x05,0x10,0x0C},
+ {0x05,0x11,0x0B},
+ {0x05,0x12,0x01},
+ {0x05,0x13,0x3F},
+ {0x05,0x15,0x00},
+ {0x05,0x16,0xB8},
+ {0x05,0x17,0xC1},
+ {0x05,0x18,0x49},
+ {0x05,0x19,0xAC},
+ {0x05,0x1A,0x02},
+ {0x05,0x1B,0x00},
+ {0x05,0x1C,0x00},
+ {0x05,0x1D,0x00},
+ {0x05,0x1E,0x00},
+ {0x05,0x1F,0x80},
+ {0x05,0x21,0x31},
+ {0x05,0x2A,0x00},
+ {0x05,0x2B,0x01},
+ {0x05,0x2C,0x0F},
+ {0x05,0x2D,0x03},
+ {0x05,0x2E,0x19},
+ {0x05,0x2F,0x19},
+ {0x05,0x31,0x00},
+ {0x05,0x32,0x42},
+ {0x05,0x33,0x03},
+ {0x05,0x34,0x00},
+ {0x05,0x36,0x0C},
+ {0x05,0x37,0x00},
+ {0x05,0x38,0x21},
+ {0x05,0x39,0x00},
+ {0x09,0x0E,0x02},
+ {0x09,0x43,0x01},
+ {0x09,0x49,0x03},
+ {0x09,0x4A,0x03},
+ {0x0A,0x02,0x00},
+ {0x0A,0x03,0x01},
+ {0x0A,0x04,0x01},
+ {0x0A,0x05,0x01},
+ {0x0B,0x44,0x0C},
+ {0x0B,0x46,0x00},
+ {0x0B,0x47,0x00},
+ {0x0B,0x48,0x0C},
+ {0x0B,0x4A,0x1E},
+ {0x05,0x14,0x01},
+ {0x00,0x1C,0x01},
+ {0x0B,0x24,0xDB},
+ {0x0B,0x25,0x02}
+};
+
+#endif
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/fs/i2c_addrs.sh b/bcm68620_release/release/host_customized/board/wrx/fs/i2c_addrs.sh
new file mode 100755
index 0000000..643fd4c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/fs/i2c_addrs.sh
@@ -0,0 +1,4 @@
+#! /bin/bash
+
+# Body will be inserted here by copy_host_fs target in project's main Makefile
+
diff --git a/bcm68620_release/release/host_customized/board/wrx/fs/svk_init.sh b/bcm68620_release/release/host_customized/board/wrx/fs/svk_init.sh
new file mode 100755
index 0000000..c1eece0
--- /dev/null
+++ b/bcm68620_release/release/host_customized/board/wrx/fs/svk_init.sh
@@ -0,0 +1,156 @@
+#! /bin/bash
+cd /opt/bcm68620
+
+# These files are mounted using tmpfs, so they will be deleted upon reboot
+LOCK_DIR_INIT=/tmp/bcm68620_svk_init
+FILE_INIT_DONE="$LOCK_DIR_INIT/done"
+LOCK_DIR_KERNEL_LOG_OWNED=/tmp/bcm68620_kernel_log_owned
+
+USER_APPL_ARGS=""
+KT2_PORT=""
+SWKT2_PORT=""
+KERNEL_LOG="y"
+COOP_DBA="n"
+
+while (($#)); do
+ case "$1" in
+ --kt2)
+ shift
+ KT2_PORT="$1"
+ ;;
+ --swkt2)
+ shift
+ SWKT2_PORT="$1"
+ ;;
+ --proxy) # for backward compatibility (could just use '-proxy')
+ shift
+ USER_APPL_ARGS="$USER_APPL_ARGS -proxy $1"
+ ;;
+ -nl)
+ KERNEL_LOG="n"
+ USER_APPL_ARGS="$USER_APPL_ARGS $1"
+ ;;
+ -coop_dba)
+ COOP_DBA="y"
+ ;;
+ *)
+ USER_APPL_ARGS="$USER_APPL_ARGS $1"
+ ;;
+ esac
+ shift
+done
+
+# Check if the initialization steps (installing kernel modules, etc) have already been done.
+# If not, start the initialization process.
+if mkdir "$LOCK_DIR_INIT" 2>/dev/null; then
+ trap "rmdir \"$LOCK_DIR_INIT\"" EXIT
+ echo "Initializing BCM68620 SVK..."
+
+ insmod ll_pcie.ko
+ sleep 1
+
+ insmod os_linux.ko
+ sleep 1
+
+ source ./i2c_addrs.sh
+ insmod i2c_devs.ko
+ sleep 1
+
+ function probe_dev
+ {
+ 2>/dev/null echo maple_i2c 0x$1 > /sys/bus/i2c/devices/i2c-0/new_device
+ }
+
+ # Suppress error warnings in case device cannot be probed because it is inexistent.
+ dmesg -n 1
+ probe_dev $I2C_SW0_I2C_ADDR
+ probe_dev $I2C_SW1_I2C_ADDR
+ probe_dev $I2C_SW2_I2C_ADDR
+ probe_dev $I2C_SW3_I2C_ADDR
+ probe_dev $I2C_SW4_I2C_ADDR
+ probe_dev $SFP_I2C_ADDR1
+ probe_dev $SFP_I2C_ADDR2
+ probe_dev $FPGA_I2C_ADDR
+ probe_dev $PON_DPLL_I2C_ADDR
+ probe_dev $PM_DPLL_I2C_ADDR
+ probe_dev $CXP_T_I2C_ADDR
+ probe_dev $CXP_R_I2C_ADDR
+ probe_dev $PCIE_SW_I2C_ADDR
+ dmesg -n 8
+
+ rm -f /dev/maple_i2c
+ mknod /dev/maple_i2c c `cat /sys/module/i2c_devs/parameters/maple_i2c_chrdev_major` 0
+
+ if [ "$KT2_PORT" != "" ]; then
+ echo k 1 > /proc/maple_i2c/i2c
+ insmod linux-kernel-bde.ko
+ sleep 1
+ cat /proc/linux-kernel-bde
+ sleep 1
+ insmod linux-uk-proxy.ko
+ sleep 1
+ mknod /dev/linux-uk-proxy c 125 0
+ sleep 1
+ insmod linux-bcm-diag-full.ko
+ sleep 1
+ echo "KT2 will wait on port $KT2_PORT"
+ ./bcm.user.proxy -d $KT2_PORT &
+ fi
+
+ if [ "$SWKT2_PORT" != "" ]; then
+ echo "SW KT2 init"
+ insmod linux-kernel-bde.ko
+ sleep 1
+ cat /proc/linux-kernel-bde
+ sleep 1
+ insmod linux-uk-proxy.ko
+ sleep 1
+ mknod /dev/linux-uk-proxy c 125 0
+ sleep 1
+ insmod linux-bcm-diag-full.ko
+ sleep 1
+ echo "KT2 will wait on port $SWKT2_PORT"
+ ./bcm.user.proxy -d $SWKT2_PORT &
+ fi
+
+ insmod bcm_dev_ctrl_linux.ko
+ sleep 1
+
+ if [ "$COOP_DBA" != "n" ]; then
+ insmod coop_dba_linux.ko
+ sleep 1
+ fi
+
+ rm -f /dev/bcm_log
+ mknod /dev/bcm_log c `cat /sys/module/bcm_dev_ctrl_linux/parameters/dev_log_chrdev_major` 0
+ mknod /dev/maple_dev_ctrl c `cat /sys/module/bcm_dev_ctrl_linux/parameters/maple_dev_ctrl_chrdev_major` 0
+
+ touch "$FILE_INIT_DONE"
+ trap - EXIT
+else
+ if [ -f "$FILE_INIT_DONE" ]; then
+ echo "Skipped BCM68620 SVK initialization since it has already been done"
+ else
+ echo "Waiting for SVK initialization to complete..."
+ while [ ! -f "$FILE_INIT_DONE" ]; do
+ sleep 1
+ done
+ fi
+fi
+
+# Only one application can have the kernel logger enabled at once.
+# If someone else already owns the kernel logger, run without it.
+if [ "$KERNEL_LOG" == "y" ]; then
+ if mkdir "$LOCK_DIR_KERNEL_LOG_OWNED" 2>/dev/null; then
+ trap "rmdir \"$LOCK_DIR_KERNEL_LOG_OWNED\"" EXIT
+ else
+ USER_APPL_ARGS="$USER_APPL_ARGS -nl"
+ echo "Running without kernel logger since someone else owns it"
+ fi
+fi
+
+#echo "In Band: Launching BCM68620 user space device control application "
+#./bcm_dev_ctrl_user > /dev/null 2>&1 &
+
+echo "Launching BCM68620 user application with options \"$USER_APPL_ARGS\""
+./bcm_user_appl $USER_APPL_ARGS
diff --git a/bcm68620_release/release/host_customized/coop_dba_linux/Makefile b/bcm68620_release/release/host_customized/coop_dba_linux/Makefile
new file mode 100644
index 0000000..9e2043e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/coop_dba_linux/Makefile
@@ -0,0 +1,38 @@
+# Cooperative DBA
+
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = coop_dba_linux
+MOD_TYPE = linux_module
+MOD_DEPS = coop_dba
+
+srcs = bcmolt_coop_dba_linux.c
+
+MOD_INC_DIRS = $(SRC_DIR) $(MODEL_OUT_DIR)
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+ ifeq ("$(RELEASE_BUILD)", "y")
+ KBUILD_EXTRA_SYMBOLS += $(TOP_DIR)/host_driver/dev_ctrl/linux/Module.symvers
+ EXTRA_CFLAGS += -I$(TOP_DIR)/host_driver/common_gpon \
+-I$(TOP_DIR)/host_driver/transport/pcie_sw_queue \
+-I$(TOP_DIR)/host_driver/pcie \
+-I$(TOP_DIR)/host_driver/api \
+-I$(TOP_DIR)/host_driver/utils \
+-I$(TOP_DIR)/host_reference/dev_log \
+-I$(TOP_DIR)/host_driver/transport/mux
+ else
+ KBUILD_EXTRA_SYMBOLS += $(TOP_DIR)/host/dev_ctrl/linux/Module.symvers
+ EXTRA_CFLAGS += -I$(TOP_DIR)/common/gpon \
+-I$(TOP_DIR)/common/model/maple \
+-I$(TOP_DIR)/common/transport/driver/maple/pcie_sw_queue \
+-I$(TOP_DIR)/common/drivers/maple/pcie \
+-I$(TOP_DIR)/common/api \
+-I$(TOP_DIR)/common/utils \
+-I$(TOP_DIR)/common/dev_log \
+-I$(TOP_DIR)/host/transport/driver/maple/mux
+ endif
+endif
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/coop_dba_linux/bcmolt_coop_dba_linux.c b/bcm68620_release/release/host_customized/coop_dba_linux/bcmolt_coop_dba_linux.c
new file mode 100644
index 0000000..70fc52c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/coop_dba_linux/bcmolt_coop_dba_linux.c
@@ -0,0 +1,81 @@
+/*
+<: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_coop_dba.h"
+
+module_param(bcmos_sys_trace_level, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+MODULE_PARM_DESC(bcmos_sys_trace_level, "trace_level");
+
+static void bcmolt_coop_dba_unregister_registered_devices(bcmolt_devid max_devid, bcmtrmux_channel channel)
+{
+ bcmolt_devid devid;
+
+ for (devid = 0; devid < max_devid; devid++)
+ {
+ bcmolt_coop_dba_exit(devid, channel);
+ }
+}
+static void bcmolt_coop_dba_module_exit(void)
+{
+ bcmolt_coop_dba_unregister_registered_devices(BCMTR_MAX_OLTS, URGENT_CHANNEL);
+
+ printk("%s\n", __FUNCTION__);
+}
+
+static int bcmolt_coop_dba_module_init(void)
+{
+ bcmos_errno rc;
+ bcmolt_devid devid;
+ bcmtrmux_channel channel = URGENT_CHANNEL;
+
+ printk("%s\n", __FUNCTION__);
+
+#if 0
+ bcmos_trace_level_set(BCMOS_TRACE_LEVEL_DEBUG);
+#endif
+
+ for (devid = 0; devid < BCMTR_MAX_OLTS; devid++)
+ {
+ rc = bcmolt_coop_dba_init(devid, &channel, bcmolt_coop_dba_rx, NULL);
+ if (rc != BCM_ERR_OK)
+ {
+ printk("error in bcmolt_coop_dba_init rc=%d\n", rc);
+ bcmolt_coop_dba_unregister_registered_devices(devid, channel);
+ break;
+ }
+ }
+
+ return rc ? -EINVAL : 0;
+}
+
+module_init(bcmolt_coop_dba_module_init);
+module_exit(bcmolt_coop_dba_module_exit);
+
+MODULE_DESCRIPTION("Cooperative DBA");
+MODULE_LICENSE("Dual BSD/GPL");
diff --git a/bcm68620_release/release/host_customized/dev_ctrl_linux/Makefile b/bcm68620_release/release/host_customized/dev_ctrl_linux/Makefile
new file mode 100644
index 0000000..39a56ff
--- /dev/null
+++ b/bcm68620_release/release/host_customized/dev_ctrl_linux/Makefile
@@ -0,0 +1,17 @@
+# device_control Linux wrapper
+
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = bcm_dev_ctrl_linux
+MOD_TYPE = linux_module
+MOD_DEPS = dev_ctrl nltr dev_log_kernel user_config host_api_linux api_linux pcie pcie_mod
+
+srcs = bcmolt_dev_ctrl_linux.c
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+endif
+
diff --git a/bcm68620_release/release/host_customized/dev_ctrl_linux/bcmolt_dev_ctrl_ioctl.h b/bcm68620_release/release/host_customized/dev_ctrl_linux/bcmolt_dev_ctrl_ioctl.h
new file mode 100755
index 0000000..037c467
--- /dev/null
+++ b/bcm68620_release/release/host_customized/dev_ctrl_linux/bcmolt_dev_ctrl_ioctl.h
@@ -0,0 +1,30 @@
+/*
+ * bcmolt_dev_ctrl_ioctl.h
+ *
+ * Created on: 7 ???? 2015
+ * Author: milya
+ */
+
+#ifndef HOST_DEV_CTRL_LINUX_BCMOLT_DEV_CTRL_IOCTL_H_
+#define HOST_DEV_CTRL_LINUX_BCMOLT_DEV_CTRL_IOCTL_H_
+
+
+#include <linux/ioctl.h>
+
+typedef struct
+{
+ uint32_t *dumpptr;
+ int32_t start_index;
+ int32_t howmany;
+ uint8_t device;
+ uint32_t event; /* For MAPLE_DEV_CTRL_IOCTL_OP_HOST_EVENT_WRITE only */
+} dev_ctrl_ioctl_param;
+
+#define MAPLE_DEV_CTRL_IOCTL_MAGIC 'J'
+
+#define MAPLE_DEV_CTRL_IOCTL_OP_PCI_STAT _IOW(MAPLE_DEV_CTRL_IOCTL_MAGIC, 1, dev_ctrl_ioctl_param)
+#define MAPLE_DEV_CTRL_IOCTL_OP_PCI_DUMP_TX _IOW(MAPLE_DEV_CTRL_IOCTL_MAGIC, 2, dev_ctrl_ioctl_param)
+#define MAPLE_DEV_CTRL_IOCTL_OP_PCI_DUMP_RX _IOWR(MAPLE_DEV_CTRL_IOCTL_MAGIC, 3, dev_ctrl_ioctl_param)
+#define MAPLE_DEV_CTRL_IOCTL_OP_HOST_EVENT_WRITE _IOW(MAPLE_DEV_CTRL_IOCTL_MAGIC, 4, dev_ctrl_ioctl_param)
+
+#endif /* HOST_DEV_CTRL_LINUX_BCMOLT_DEV_CTRL_IOCTL_H_ */
diff --git a/bcm68620_release/release/host_customized/dev_ctrl_linux/bcmolt_dev_ctrl_linux.c b/bcm68620_release/release/host_customized/dev_ctrl_linux/bcmolt_dev_ctrl_linux.c
new file mode 100644
index 0000000..5f48de4
--- /dev/null
+++ b/bcm68620_release/release/host_customized/dev_ctrl_linux/bcmolt_dev_ctrl_linux.c
@@ -0,0 +1,370 @@
+#include <linux/proc_fs.h>
+#include <bcmolt_tr_nl_driver.h>
+#include <bcmolt_dev_log_kernel.h>
+#include <bcm_dev_log.h>
+#include <bcmolt_dev_ctrl.h>
+#include <bcmolt_tr_mux.h>
+#include <bcmos_system.h>
+#include <linux/cdev.h>
+#include <asm/uaccess.h> /*copy_from_user*/
+#include <linux/proc_fs.h>
+#include <bcmolt_dev_ctrl_ioctl.h>
+#include <bcmolt_user_utils.h>
+#include <bcmolt_host_api.h>
+#include <bcmolt_fld.h>
+#include <bcmtr_pcie.h>
+
+module_param(bcmos_sys_trace_level, uint, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+MODULE_PARM_DESC(bcmos_sys_trace_level, "trace_level");
+
+
+int maple_dev_ctrl_chrdev_major = 237;
+module_param(maple_dev_ctrl_chrdev_major, int, S_IRUSR | S_IRGRP | S_IWGRP);
+MODULE_PARM_DESC(maple_dev_ctrl_chrdev_major, "maple_dev_ctrl_major");
+static char is_chrdev_reg;
+static char is_cdev_add;
+
+extern struct proc_dir_entry *bcmolt_dir;
+
+bcmos_errno bcmtr_init(void)
+{
+ return BCM_ERR_OK;
+}
+
+/* /proc/bcmolt/trmux read operation */
+static int trmux_stats_read(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+ static bcmtrmux_stat prev_stat;
+ int len;
+ bcmtrmux_stat stat;
+ bcmos_errno rc;
+ bcmolt_devid *device_id = data;
+
+ rc = bcmtrmux_stat_get(*device_id, &stat);
+ if (rc)
+ {
+ len = snprintf(page, count, "Can't read trmux statistics rc=%s\n", bcmos_strerror(rc));
+ return len;
+ }
+
+ len = snprintf(page, count, "trmux statistics\n\n");
+ len += sprintf(page + len, "tx_remote : %u\n", stat.tx_remote - prev_stat.tx_remote);
+ len += sprintf(page + len, "tx_local : %u\n", stat.tx_local - prev_stat.tx_local);
+ len += sprintf(page + len, "tx_disc_remote : %u\n", stat.tx_disc_remote - prev_stat.tx_disc_remote);
+ len += sprintf(page + len, "tx_disc_local : %u\n", stat.tx_disc_local - prev_stat.tx_disc_local);
+ len += sprintf(page + len, "rx_remote : %u\n", stat.rx_remote - prev_stat.rx_remote);
+ len += sprintf(page + len, "rx_local : %u\n", stat.rx_local - prev_stat.rx_local);
+ len += sprintf(page + len, "rx_auto : %u\n", stat.rx_auto - prev_stat.rx_auto);
+ len += sprintf(page + len, "rx_disc_remote : %u\n", stat.rx_disc_remote - prev_stat.rx_disc_remote);
+ len += sprintf(page + len, "rx_disc_local : %u\n", stat.rx_disc_local - prev_stat.rx_disc_local);
+ len += sprintf(page + len, "rx_disc_auto : %u\n", stat.rx_disc_auto - prev_stat.rx_disc_auto);
+ len += sprintf(page + len, "ctl_to_host : %u\n", stat.control_to_host - prev_stat.control_to_host);
+ len += sprintf(page + len, "ctl_to_line : %u\n", stat.control_to_line - prev_stat.control_to_line);
+ len += sprintf(page + len, "rx_disc_inv_ch : %u\n", stat.rx_disc_inv_ch - prev_stat.rx_disc_inv_ch);
+ len += sprintf(page + len, "rx_poll_urgent : %u\n", stat.rx_poll_urgent - prev_stat.rx_poll_urgent);
+ len += sprintf(page + len, "rx_poll_normal : %u\n", stat.rx_poll_normal - prev_stat.rx_poll_normal);
+ prev_stat = stat;
+
+ return len;
+}
+
+/* /proc/bcmolt/devctrl read operation */
+static int devctrl_debug_read(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+ int len;
+ dev_ctrl_database db;
+ bcmolt_devid *device_id = data;
+
+ dev_ctrl_read_db(*device_id, &db);
+
+ /* db contains the entire copy of dev_ctrl_database. add whatever you want to print. */
+ len = snprintf(page, count, "dev_ctrl debug information\n\n");
+ len += sprintf(page + len, "task name : %s\n", db.task_info.name);
+ len += sprintf(page + len, "module name : %s\n", db.module_info.name);
+ len += sprintf(page + len, "connection state : %s\n",
+ bcm_str_host_connecting_state(db.connection_info.state));
+ len += sprintf(page + len, "tod : %s\n",
+ (db.enable_tod == BCMOLT_CONTROL_STATE_DISABLE) ? "DISABLE" : "ENABLE");
+ len += sprintf(page + len, "last event : %s\n", bcm_str_device_event(db.last_event));
+ if (db.conn_fail_reason < BCMOLT_HOST_CONNECTION_FAIL_REASON__NUM_OF)
+ len += sprintf(page + len, "connection failure reason : %s\n",
+ bcm_str_host_connection_fail_reason(db.conn_fail_reason));
+ return len;
+}
+
+#ifdef ENABLE_LOG
+static bcmos_errno dev_ctrl_logger_init_cb(void)
+{
+ bcmos_errno rc;
+
+ /* Create kernel logger */
+ rc = bcm_dev_log_linux_init();
+ BUG_ON(rc);
+
+ /* For now just map BCMOS_TRACE_XX to dev_log. Later on dev_control
+ * can define its own log ids
+ */
+ rc = bcm_dev_log_os_trace_init();
+ BUG_ON(rc);
+
+ return rc;
+}
+#endif
+
+static struct cdev maple_dev_ctrl_chrdev_cdev;
+static int maple_dev_ctrl_chrdev_open(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static int maple_dev_ctrl_chrdev_release(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static long maple_dev_ctrl_chrdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ bcmos_errno bcmrc;
+ int linux_rc = 0;
+ int rc = 0;
+ dev_ctrl_ioctl_param params;
+
+ /* don't even decode wrong cmds: better returning ENOTTY than EFAULT */
+ if (_IOC_TYPE(cmd) != MAPLE_DEV_CTRL_IOCTL_MAGIC)
+ return -ENOTTY;
+
+ rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (rc < 0)
+ return rc;
+
+ switch (cmd)
+ {
+ case MAPLE_DEV_CTRL_IOCTL_OP_PCI_STAT:
+ {
+ bcm_pcied_stat stat;
+
+ memset(params.dumpptr, 0, sizeof(bcm_pcied_stat));
+ bcmrc = bcmtr_pcie_get_statistics(params.device, params.start_index, &stat);
+ if (bcmrc == BCM_ERR_OK)
+ memcpy(params.dumpptr, &stat, sizeof(bcm_pcied_stat));
+ else
+ linux_rc = (int)bcmrc;
+ }
+ break;
+ case MAPLE_DEV_CTRL_IOCTL_OP_PCI_DUMP_TX:
+ linux_rc = (int)bcmtr_pcie_tx_dump((char *)params.dumpptr, params.device, params.start_index, params.howmany);
+ break;
+ case MAPLE_DEV_CTRL_IOCTL_OP_PCI_DUMP_RX:
+ linux_rc = (int)bcmtr_pcie_rx_dump((char *)params.dumpptr, params.device, params.start_index, params.howmany);
+ break;
+ case MAPLE_DEV_CTRL_IOCTL_OP_HOST_EVENT_WRITE:
+ linux_rc = (int)bcmolt_dev_ctrl_host_event_write(params.device, params.event);
+ break;
+ default:
+ rc = -ENOTTY;
+ break;
+ }
+
+ return linux_rc;
+}
+static ssize_t maple_dev_ctrl_chrdev_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *f_pos)
+{
+ return 0;
+}
+
+static struct file_operations maple_dev_ctrl_chrdev_fops =
+{
+ .owner = THIS_MODULE,
+ .open = maple_dev_ctrl_chrdev_open,
+ .release = maple_dev_ctrl_chrdev_release,
+ .write = maple_dev_ctrl_chrdev_write,
+ .unlocked_ioctl = maple_dev_ctrl_chrdev_ioctl
+};
+
+static int maple_dev_ctrl_dev_create_chrdev(void)
+{
+ dev_t dev = MKDEV(maple_dev_ctrl_chrdev_major, 0);
+ int linux_rc;
+ is_chrdev_reg = 0;
+ is_cdev_add = 0;
+ /*
+ * Register your major, and accept a dynamic number.
+ */
+ if (!maple_dev_ctrl_chrdev_major)
+ return -1;
+ linux_rc = register_chrdev_region(dev, 0, "maple_dev_ctrl");
+ if (linux_rc < 0)
+ {
+ printk("register_chrdev_region()->%d\n", linux_rc);
+ return -EIO;
+ }
+ is_chrdev_reg = 1;
+
+ cdev_init(&maple_dev_ctrl_chrdev_cdev, &maple_dev_ctrl_chrdev_fops);
+ linux_rc = cdev_add(&maple_dev_ctrl_chrdev_cdev, dev, 1);
+ if (linux_rc < 0)
+ {
+ printk("cdev_add()->%d\n", linux_rc);
+ return -EIO;
+ }
+ is_cdev_add = 1;
+ return 0;
+}
+
+
+#define BCMOLT_PROCFS_NAME_LEN 4 /* device_id is 1-byte, which can be 3 digit in decimal. */
+#define PROC_TRMUX_NAME "trmux"
+#define PROC_DEVCTRL_NAME "devctrl"
+#define PROC_ENTRY_MODE (S_IFREG | S_IWUSR | S_IRUGO)
+
+typedef struct
+{
+ bcmolt_devid device_id;
+ char name[BCMOLT_PROCFS_NAME_LEN];
+} bcmolt_proc_ctx_t;
+
+static bcmolt_proc_ctx_t bcmolt_proc_ctx[BCMTR_MAX_OLTS];
+static bcmos_bool bcmdev_bcmolt_proc_initialized;
+struct proc_dir_entry *trmux_dir = NULL;
+struct proc_dir_entry *devctrl_dir = NULL;
+
+static void bcmdev_bcmolt_proc_init(void)
+{
+ bcmolt_devid devid;
+ if (!bcmdev_bcmolt_proc_initialized)
+ {
+ for (devid = 0; devid < BCMTR_MAX_OLTS; devid++)
+ {
+ bcmolt_proc_ctx[devid].device_id = devid;
+ sprintf(bcmolt_proc_ctx[devid].name, "%d", devid);
+ }
+ bcmdev_bcmolt_proc_initialized = BCMOS_TRUE;
+ }
+}
+
+static void bcmdev_module_exit(void)
+{
+ int devid;
+
+ if (trmux_dir)
+ {
+ for (devid = 0; devid < BCMTR_MAX_OLTS; devid++)
+ {
+ remove_proc_entry(bcmolt_proc_ctx[devid].name, trmux_dir);
+ }
+ remove_proc_entry(PROC_TRMUX_NAME, bcmolt_dir);
+ }
+ if (devctrl_dir)
+ {
+ for (devid = 0; devid < BCMTR_MAX_OLTS; devid++)
+ {
+ remove_proc_entry(bcmolt_proc_ctx[devid].name, devctrl_dir);
+ }
+ remove_proc_entry(PROC_DEVCTRL_NAME, bcmolt_dir);
+ }
+
+ bcmolt_dev_ctrl_exit();
+ bcmtr_nl_exit();
+ if (is_cdev_add)
+ cdev_del(&maple_dev_ctrl_chrdev_cdev);
+ if (is_chrdev_reg)
+ unregister_chrdev_region(MKDEV(maple_dev_ctrl_chrdev_major, 0), 1);
+#if defined(ENABLE_LOG)
+ bcm_dev_log_linux_exit();
+ bcm_dev_log_destroy();
+#endif
+ printk("%s\n", __FUNCTION__);
+}
+
+static int bcmdev_module_init(void)
+{
+ bcmos_errno rc;
+ struct proc_dir_entry *trmux_file;
+ struct proc_dir_entry *devctrl_file;
+ bcmolt_devid devid;
+ bcmolt_host_init_params params =
+ {
+#ifdef ENABLE_LOG
+ .logger_init_cb = dev_ctrl_logger_init_cb,
+#endif
+ .dev_ctrl_params =
+ {
+ .image_read_cb = bcmuser_image_read,
+ .system_mode_validate_cb = bcmuser_system_mode_validate,
+ .device_off_cb = bcmuser_device_off,
+ .device_on_cb = bcmuser_device_on,
+ .device_is_running_cb = bcmuser_device_is_running,
+ .host_reset_cb = bcmuser_host_reset,
+ .pcie_channel_prepare_cb = bcmuser_pcie_channel_prepare,
+ .pcie_channel_remove_cb = bcmuser_pcie_channel_remove,
+ }
+ };
+
+ if (!is_cdev_add)
+ {
+ if (maple_dev_ctrl_dev_create_chrdev() < 0)
+ printk("%s error to create dev ctrl cdev \n", __FUNCTION__);
+ }
+
+ printk("%s\n", __FUNCTION__);
+
+ rc = bcmolt_host_init(¶ms);
+ BUG_ON(rc);
+
+ bcmos_trace_level_set(BCMOS_TRACE_LEVEL_DEBUG);
+
+ bcmdev_bcmolt_proc_init();
+
+ rc = bcmtr_nl_init();
+ BUG_ON(rc);
+
+ rc = bcmuser_pcie_prepare();
+
+ if (rc == BCM_ERR_OK)
+ {
+ if ((trmux_dir = create_proc_entry(PROC_TRMUX_NAME, S_IFDIR, bcmolt_dir)) == NULL)
+ {
+ printk("Unable to create /proc/bcmolt/trmux directory\n");
+ return -1;
+ }
+
+ if ((devctrl_dir = create_proc_entry(PROC_DEVCTRL_NAME, S_IFDIR, bcmolt_dir)) == NULL)
+ {
+ printk("Unable to create /proc/bcmolt/devctrl directory\n");
+ return -1;
+ }
+
+ for (devid = 0; devid < BCMTR_MAX_OLTS; devid++)
+ {
+ if ((trmux_file = create_proc_entry(bcmolt_proc_ctx[devid].name, PROC_ENTRY_MODE, trmux_dir)) == NULL)
+ {
+ printk("Unable to create /proc/bcmolt/%s/%s\n", PROC_TRMUX_NAME, bcmolt_proc_ctx[devid].name);
+ return -1;
+ }
+ trmux_file->read_proc = (read_proc_t *)trmux_stats_read;
+ trmux_file->data = &bcmolt_proc_ctx[devid].device_id;
+
+ if ((devctrl_file = create_proc_entry(bcmolt_proc_ctx[devid].name, PROC_ENTRY_MODE, devctrl_dir)) == NULL)
+ {
+ printk("Unable to create /proc/bcmolt/%s/%s\n", PROC_DEVCTRL_NAME, bcmolt_proc_ctx[devid].name);
+ return -1;
+ }
+ devctrl_file->read_proc = (read_proc_t *)devctrl_debug_read;
+ devctrl_file->data = &bcmolt_proc_ctx[devid].device_id;
+ }
+ }
+ else
+ {
+ bcmos_usleep(2000000);
+ bcmdev_module_exit();
+ }
+
+ return rc ? -EINVAL : 0;
+}
+
+module_init(bcmdev_module_init);
+module_exit(bcmdev_module_exit);
+
+MODULE_DESCRIPTION("device_control");
+MODULE_LICENSE("Dual BSD/GPL");
diff --git a/bcm68620_release/release/host_customized/embedded_cli/Makefile b/bcm68620_release/release/host_customized/embedded_cli/Makefile
new file mode 100644
index 0000000..3867ac3
--- /dev/null
+++ b/bcm68620_release/release/host_customized/embedded_cli/Makefile
@@ -0,0 +1,13 @@
+# Host API
+#
+ifeq ("$(ENABLE_CLI)", "y")
+ MOD_NAME = embedded_cli
+ MOD_TYPE = lib
+ MOD_DEPS = transport model cli
+ifeq ("$(RELEASE_BUILD)", "y")
+ MOD_DEPS += common_api
+else
+ MOD_DEPS += api
+endif
+ srcs = bcmolt_embedded_cli.c
+endif
diff --git a/bcm68620_release/release/host_customized/embedded_cli/bcmolt_embedded_cli.c b/bcm68620_release/release/host_customized/embedded_cli/bcmolt_embedded_cli.c
new file mode 100644
index 0000000..0c5a8f7
--- /dev/null
+++ b/bcm68620_release/release/host_customized/embedded_cli/bcmolt_embedded_cli.c
@@ -0,0 +1,268 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcm_embedded_cli.c - embedded CLI access from the host
+ */
+
+#include <bcmos_system.h>
+#include <bcmolt_embedded_cli.h>
+#include <bcmolt_model_types.h>
+#include <bcmolt_api.h>
+#include <bcmtr_interface.h>
+#include <bcmcli.h>
+
+#define EMBEDDED_CLI_BUFFER_SIZE 2048
+#define EMBEDDED_CLI_TIMER_DELAY_US 100000
+
+/* Embedded CLI client context */
+typedef struct
+{
+ bcmolt_devid device;
+ bcmos_task task;
+ bcmos_timer timer;
+ bcmcli_session *session;
+ uint8_t inbuf[EMBEDDED_CLI_BUFFER_SIZE];
+ uint32_t inbuf_length;
+} embedded_cli_context;
+
+static embedded_cli_context *cli_context;
+
+static bcmos_timer_rc embedded_cli_timer_handler(bcmos_timer *timer, long data)
+{
+ /* FFU: this timer is for future line editing support */
+ return BCMOS_TIMER_OK;
+}
+
+static void embedded_cli_output_msg_handler(bcmolt_devid olt, bcmolt_msg *msg)
+{
+ bcmolt_debug_cli_input *cli_msg = (bcmolt_debug_cli_input *)msg;
+
+ if (cli_context && cli_msg->data.data.val)
+ {
+ /* print directly because output can contain ESC sequences */
+ uint8_t *val = cli_msg->data.data.val;
+ while (*val)
+ {
+ bcmos_putchar(*(val++));
+ }
+ }
+ bcmolt_msg_free(msg);
+}
+
+static void embedded_cli_send_input(embedded_cli_context *context)
+{
+ bcmolt_debug_key key = {};
+ bcmolt_debug_cli_input msg;
+ bcmolt_u8_list_u32 data = { context->inbuf_length, context->inbuf };
+
+ if (!context->inbuf_length)
+ {
+ return;
+ }
+ BCMOLT_OPER_INIT(&msg, debug, cli_input, key);
+ BCMOLT_OPER_PROP_SET(&msg, debug, cli_input, data, data);
+ bcmolt_oper_submit(context->device, &msg.hdr);
+ context->inbuf_length = 0;
+}
+
+/* Initialize embedded CLI module */
+bcmos_errno bcm_embedded_cli_enter(bcmcli_session *session, bcmolt_devid device)
+{
+ static char *embedded_cli_task_name = "embedded_cli";
+ bcmos_task_parm taskp =
+ {
+ .name = embedded_cli_task_name,
+ .priority = TASK_PRIORITY_CLI,
+ .data = device
+ };
+ bcmos_module_parm modulep = {};
+ bcmos_timer_parm timerp =
+ {
+ .owner = BCMOS_MODULE_ID_CLI_OVER_PCIE,
+ .handler = embedded_cli_timer_handler,
+ .data = device
+ };
+ bcmtr_handler_parm msgp =
+ {
+ .object = BCMOLT_OBJ_ID_DEBUG,
+ .group = BCMOLT_MGT_GROUP_AUTO,
+ .subgroup = BCMOLT_DEBUG_AUTO_ID_CLI_OUTPUT,
+ .module = BCMOS_MODULE_ID_CLI_OVER_PCIE,
+ .app_cb = embedded_cli_output_msg_handler,
+ .flags = BCMOLT_AUTO_FLAGS_DISPATCH
+ };
+ bcmtr_handler_parm old_msgp =
+ {
+ .object = BCMOLT_OBJ_ID_DEBUG,
+ .group = BCMOLT_MGT_GROUP_AUTO,
+ .subgroup = BCMOLT_DEBUG_AUTO_ID_CLI_OUTPUT,
+ };
+
+ int c;
+ bcmos_errno rc;
+ bcmos_bool raw_mode = BCMOS_FALSE;
+
+ /* Only 1 instance is supported */
+ if (cli_context)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_ALREADY, "embedded_cli client is already active for device %u\n",
+ cli_context->device);
+ }
+ cli_context = bcmos_calloc(sizeof(*cli_context));
+ if (!cli_context)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "can't allocate embedded CLI context\n");
+ }
+ cli_context->session = session;
+ cli_context->device = device;
+
+ /* Create input/output task & module */
+ rc = bcmos_task_create(&cli_context->task, &taskp);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Can't create embedded cli task: %s\n", bcmos_strerror(rc));
+ goto cleanup1;
+ }
+
+ modulep.data = (long)cli_context;
+ rc = bcmos_module_create(BCMOS_MODULE_ID_CLI_OVER_PCIE, &cli_context->task, &modulep);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Can't create embedded cli module: %s\n", bcmos_strerror(rc));
+ goto cleanup2;
+ }
+
+ timerp.data = (long)cli_context;
+ rc = bcmos_timer_create(&cli_context->timer, &timerp);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Can't create embedded cli timer: %s\n", bcmos_strerror(rc));
+ goto cleanup3;
+ }
+
+ /* Query existing indication in order to be able to restore it */
+ bcmtr_msg_handler_register_get(device, &old_msgp);
+
+ /* Unregister old handler */
+ bcmtr_msg_handler_unregister(device, &old_msgp);
+
+ /* Register for cli_output indication */
+ rc = bcmtr_msg_handler_register(device, &msgp);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Can't register for cli_output indication: %s\n", bcmos_strerror(rc));
+ goto cleanup4;
+ }
+
+ bcmcli_session_print(session, "Device %u: Entering embedded CLI. Type %c to terminate\n",
+ device, BCM_EMBEDDED_CONSOLE_EXIT_CHAR);
+
+ /* Try to enter raw mode if line editing is requested */
+ rc = bcmcli_session_raw_mode_set(session, BCMOS_TRUE);
+ if (rc)
+ {
+ bcmcli_session_print(session, "Can't enable RAW input mode. Line editing is disabled\n");
+ }
+ else
+ {
+ raw_mode = BCMOS_TRUE;
+ }
+ /* No we read input and push it into input buffer */
+ if (raw_mode)
+ {
+ c = bcmos_getchar();
+ while (c >= 0 && c != BCM_EMBEDDED_CONSOLE_EXIT_CHAR)
+ {
+ cli_context->inbuf[cli_context->inbuf_length++] = c;
+ embedded_cli_send_input(cli_context);
+ c = bcmos_getchar();
+ }
+ bcmcli_session_raw_mode_set(session, BCMOS_FALSE);
+ }
+ else
+ {
+ /* Line mode */
+ char *buf;
+
+ buf = bcmcli_session_gets(session, (char *)cli_context->inbuf, sizeof(cli_context->inbuf));
+ while (buf && buf[0] != BCM_EMBEDDED_CONSOLE_EXIT_CHAR)
+ {
+ cli_context->inbuf_length = strlen(buf);
+ if (!cli_context->inbuf_length)
+ continue;
+ if (buf[cli_context->inbuf_length-1] != '\n' && buf[cli_context->inbuf_length-1] != '\r' &&
+ cli_context->inbuf_length < sizeof(cli_context->inbuf) - 1)
+ {
+ buf[cli_context->inbuf_length++] = '\n';
+ }
+ embedded_cli_send_input(cli_context);
+ buf = bcmcli_session_gets(session, (char *)cli_context->inbuf, sizeof(cli_context->inbuf));
+ }
+ }
+
+ bcmos_timer_stop(&cli_context->timer);
+ bcmcli_session_print(session, "Device %u: Embedded CLI terminated\n", device);
+ bcmtr_msg_handler_unregister(device, &msgp);
+ if (old_msgp.app_cb)
+ rc = bcmtr_msg_handler_register(device, &old_msgp);
+
+cleanup4:
+ bcmos_timer_destroy(&cli_context->timer);
+cleanup3:
+ bcmos_module_destroy(BCMOS_MODULE_ID_CLI_OVER_PCIE);
+cleanup2:
+ bcmos_task_destroy(&cli_context->task);
+cleanup1:
+ bcmos_free(cli_context);
+ cli_context = NULL;
+
+ return rc;
+}
+
+static bcmos_errno bcm_embedded_cli_command(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ bcmolt_devid device = parm[0].value.number;
+ return bcm_embedded_cli_enter(session, device);
+}
+
+/* Initialize embedded CLI module */
+bcmos_errno bcm_embedded_cli_init(void)
+{
+ BCMCLI_MAKE_CMD(NULL, "embedded", "Embedded CLI", bcm_embedded_cli_command,
+ BCMCLI_MAKE_PARM_RANGE("device", "Device index", BCMCLI_PARM_DECIMAL, 0, 0, BCMTR_MAX_OLTS-1));
+
+ return BCM_ERR_OK;
+}
+
+/* Cleanup embedded CVLI module */
+bcmos_errno bcm_embedded_cli_exit(void)
+{
+ return BCM_ERR_OK;
+}
diff --git a/bcm68620_release/release/host_customized/embedded_cli/bcmolt_embedded_cli.h b/bcm68620_release/release/host_customized/embedded_cli/bcmolt_embedded_cli.h
new file mode 100644
index 0000000..4a1e519
--- /dev/null
+++ b/bcm68620_release/release/host_customized/embedded_cli/bcmolt_embedded_cli.h
@@ -0,0 +1,64 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcm_embedded_cli.h - embedded CLI access from the host
+ */
+
+#ifndef BCMOLT_EMBEDDED_CLI_H_
+#define BCMOLT_EMBEDDED_CLI_H_
+
+#include <bcmcli_session.h>
+#include <bcmolt_msg.h>
+
+/* Character used to exit from embedded console */
+#define BCM_EMBEDDED_CONSOLE_EXIT_CHAR '!'
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initialize embedded CLI module */
+bcmos_errno bcm_embedded_cli_init(void);
+
+/* Cleanup embedded CLI module */
+bcmos_errno bcm_embedded_cli_exit(void);
+
+/* Connect to embedded CLI console.
+ * The function waits for user input and
+ * returns when encounters BCM_EMBEDDED_CONSOLE_EXIT_CHAR
+ */
+bcmos_errno bcm_embedded_cli_enter(bcmcli_session *session, bcmolt_devid device);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/bcm68620_release/release/host_customized/embedded_cli/main/Makefile b/bcm68620_release/release/host_customized/embedded_cli/main/Makefile
new file mode 100644
index 0000000..c6f7c95
--- /dev/null
+++ b/bcm68620_release/release/host_customized/embedded_cli/main/Makefile
@@ -0,0 +1,9 @@
+# Embedded CLI console application
+#
+ifeq ("$(ENABLE_CLI)", "y")
+ MOD_NAME = embedded_console
+ MOD_TYPE = app
+ MOD_DEPS = embedded_cli
+
+ srcs = bcmolt_embedded_console.c
+endif
diff --git a/bcm68620_release/release/host_customized/embedded_cli/main/bcmolt_embedded_console.c b/bcm68620_release/release/host_customized/embedded_cli/main/bcmolt_embedded_console.c
new file mode 100644
index 0000000..5ce767b
--- /dev/null
+++ b/bcm68620_release/release/host_customized/embedded_cli/main/bcmolt_embedded_console.c
@@ -0,0 +1,79 @@
+/*
+<: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_embedded_cli.h>
+
+static int _cli_help(void)
+{
+ fprintf(stderr, "embedded_console [-d device_index]");
+ return -1;
+}
+
+int main(int argc, char *argv[])
+{
+ bcmcli_session_parm mon_session_parm;
+ bcmcli_session *session;
+ int device = 0;
+ int i;
+
+ /* argc must be odd because all options except for argv[0] go in pairs */
+ if (!(argc % 2))
+ {
+ return _cli_help();
+ }
+
+ memset(&mon_session_parm, 0, sizeof(mon_session_parm));
+ mon_session_parm.access_right = BCMCLI_ACCESS_ADMIN;
+ for(i=1; i<argc; i++)
+ {
+ if (!strcmp(argv[i], "-d"))
+ {
+ char *pend;
+ ++i;
+ device = strtoul(argv[i], &pend, 0);
+ if (pend && *pend)
+ return _cli_help();
+ }
+ }
+
+ if (bcmcli_session_open(&mon_session_parm, &session))
+ {
+ printf("Can't open CLI session\n");
+ return -EINVAL;
+ }
+
+ /* Process user input until EOF or ! command */
+ bcm_embedded_cli_enter(session, device);
+
+ bcmcli_session_close(session);
+
+ return 0;
+}
+
diff --git a/bcm68620_release/release/host_customized/host_api_linux/Makefile b/bcm68620_release/release/host_customized/host_api_linux/Makefile
new file mode 100644
index 0000000..6ab83b5
--- /dev/null
+++ b/bcm68620_release/release/host_customized/host_api_linux/Makefile
@@ -0,0 +1,17 @@
+# Makefile for building host/host_api as linux library to be called from kernel modules
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = host_api_linux
+MOD_TYPE = linux_lib
+MOD_DEPS = common_gpon
+
+srcs = bcmolt_host_api.c
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+endif
+
diff --git a/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api.c b/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api.c
new file mode 120000
index 0000000..420887e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api.c
@@ -0,0 +1 @@
+../../host_driver/host_api/bcmolt_host_api.c
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api.h b/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api.h
new file mode 120000
index 0000000..0ebbe28
--- /dev/null
+++ b/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api.h
@@ -0,0 +1 @@
+../../host_driver/host_api/bcmolt_host_api.h
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api_gpon_utils.h b/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api_gpon_utils.h
new file mode 120000
index 0000000..66be99e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/host_api_linux/bcmolt_host_api_gpon_utils.h
@@ -0,0 +1 @@
+../../host_driver/host_api/bcmolt_host_api_gpon_utils.h
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/i2c/Makefile b/bcm68620_release/release/host_customized/i2c/Makefile
new file mode 100644
index 0000000..333c2db
--- /dev/null
+++ b/bcm68620_release/release/host_customized/i2c/Makefile
@@ -0,0 +1,19 @@
+# I2C devices driver
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = i2c_devs
+MOD_TYPE = linux_module
+
+srcs = bcmolt_i2c_devs.c
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+endif
+
+USE_LINT = yes
+
diff --git a/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs.c b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs.c
new file mode 100644
index 0000000..48e9ec4
--- /dev/null
+++ b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs.c
@@ -0,0 +1,1038 @@
+/*
+<: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 <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/i2c.h>
+#include <linux/err.h>
+#include <linux/cdev.h>
+#include <asm/uaccess.h> /*copy_from_user*/
+#include <linux/proc_fs.h>
+#include "bcmos_system.h"
+#include "bcmolt_i2c_devs.h"
+#include "bcmolt_i2c_devs_ioctl.h"
+
+#define BCM_I2C_DEV_ADDR_START typedef enum {
+#define BCM_I2C_DEV_ADDR(name, desc, val) name = val,
+#define BCM_I2C_DEV_ADDR_END } bcm_i2c_dev_addr;
+
+#include "bcmolt_i2c_devs_addr.h"
+
+#define PROC_DIR_NAME "maple_i2c"
+#define PROC_ENTRY_NAME "i2c"
+#define MAX_EAGAIN_ITERS 200 /* 10ms per iter */
+
+/* uncomment the next line to enable debug output to the kernel CLI */
+/* #define I2C_DEBUG_PRINTS 1 */
+#ifdef I2C_DEBUG_PRINTS
+#define i2c_debug_print(fmt, args...) printk("%s#%d: " fmt, __FUNCTION__, __LINE__, ## args)
+#else
+#define i2c_debug_print(...)
+#endif
+
+int maple_i2c_chrdev_major = 216;
+module_param(maple_i2c_chrdev_major, int, S_IRUSR | S_IRGRP | S_IWGRP);
+MODULE_PARM_DESC(maple_i2c_chrdev_major, "maple_i2c_major");
+
+static struct proc_dir_entry *i2c_proc_dir;
+static struct proc_dir_entry *i2c_proc_entry;
+static char is_chrdev_reg;
+static char is_cdev_add;
+static int i2c_client_num;
+static int i2c_num_clients;
+
+const unsigned short normal_i2c[] = {
+ I2C_SW0_I2C_ADDR,
+ I2C_SW1_I2C_ADDR,
+ I2C_SW2_I2C_ADDR,
+ I2C_SW3_I2C_ADDR,
+ I2C_SW4_I2C_ADDR,
+ SFP_I2C_ADDR1,
+ SFP_I2C_ADDR2,
+ FPGA_I2C_ADDR,
+ PON_DPLL_I2C_ADDR,
+ PM_DPLL_I2C_ADDR,
+ CXP_R_I2C_ADDR,
+ PCIE_SW_I2C_ADDR,
+ I2C_CLIENT_END
+};
+
+static unsigned char slave_valid[SLAVE_NUM_OF_SLAVES] = {0};
+
+/*
+ * Driver data (common to all clients)
+ */
+
+static const struct i2c_device_id maple_i2c_id_table[] = {
+ { "maple_i2c", 0 },
+ { }
+};
+MODULE_DEVICE_TABLE(i2c, maple_i2c_id_table);
+
+static void bcm_access_fpga(void);
+
+/*
+ * Client data (each client gets its own)
+ */
+struct maple_i2c_data {
+ struct i2c_client client;
+};
+
+static struct maple_i2c_data *pclient_data_ar[SLAVE_NUM_OF_SLAVES];
+
+static int get_client(unsigned char client_num, struct i2c_client **client)
+{
+ if ((client_num >= SLAVE_NUM_OF_SLAVES) || !slave_valid[client_num])
+ {
+ i2c_debug_print("I2C error: Wrong client number 0x%x\n", client_num);
+ return -1;
+ }
+ *client = &pclient_data_ar[client_num]->client;
+
+ return 0;
+}
+
+
+/*
+ * Helper functions which attempt I2C transfer until successful, or error code is other than -EAGAIN
+ */
+
+static int maple_i2c_send(unsigned char client_num, u8 *buf, size_t count)
+{
+ struct i2c_client *client;
+ int rc;
+ int niter = 0;
+
+ if (get_client(client_num, &client))
+ return -1;
+
+ do {
+ rc = i2c_master_send(client, buf, count);
+ if (rc == -EAGAIN)
+ msleep(10);
+ } while (rc == -EAGAIN && ++niter < MAX_EAGAIN_ITERS);
+ rc = (rc == count) ? 0 : (rc < 0 ) ? rc : -1;
+
+ return rc;
+}
+
+static int maple_i2c_recv(unsigned char client_num, u8 *buf, size_t count)
+{
+ struct i2c_client *client;
+ int rc;
+ int niter = 0;
+
+ if (get_client(client_num, &client))
+ return -1;
+
+ do {
+ rc = i2c_master_recv(client, buf, count);
+ if (rc == -EAGAIN)
+ msleep(10);
+ } while (rc == -EAGAIN && ++niter < MAX_EAGAIN_ITERS);
+ rc = (rc == count) ? 0 : (rc < 0 ) ? rc : -1;
+
+ return rc;
+}
+
+
+static int maple_i2c_read_with_offset(unsigned char client_num, u8 *offset, size_t offset_size, u8 *buf, size_t count)
+{
+ struct i2c_client *client;
+ struct i2c_msg msg[2];
+ int rc;
+ int niter = 0;
+
+ if (get_client(client_num, &client))
+ return -1;
+
+ msg[0].addr = msg[1].addr = client->addr;
+ msg[0].flags = msg[1].flags = client->flags & I2C_M_TEN;
+
+ msg[0].len = offset_size;
+ msg[0].buf = offset;
+
+ msg[1].flags |= I2C_M_RD;
+ msg[1].len = count;
+ msg[1].buf = buf;
+
+ do {
+ rc = i2c_transfer(client->adapter, msg, 2);
+ if (rc == -EAGAIN)
+ msleep(10);
+ } while (rc == -EAGAIN && ++niter < MAX_EAGAIN_ITERS);
+
+ rc = (rc == 2) ? 0 : (rc < 0 ) ? rc : -1;
+
+ return rc;
+}
+
+ssize_t maple_i2c_write(unsigned char client_num, char *buf, size_t count)
+{
+ int rc;
+
+ i2c_debug_print("Write to switch: client=0x%x val = 0x%x\n", normal_i2c[client_num], *buf);
+ rc = maple_i2c_send(client_num, (u8 *)buf, count);
+
+ if (rc < 0)
+ i2c_debug_print("Write Failed. rc=%d client=%u[%u]\n", rc,
+ normal_i2c[client_num], client_num);
+ else
+ i2c_debug_print("Write Successful client=%u[%u]\n",
+ normal_i2c[client_num], client_num);
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_write);
+
+ssize_t maple_i2c_read(unsigned char client_num, char *buf, size_t count)
+{
+ int rc;
+
+ i2c_debug_print("Read from switch: client 0x%x\n", normal_i2c[client_num]);
+ rc = maple_i2c_recv(client_num, (u8 *)buf, count);
+
+ if (rc < 0)
+ i2c_debug_print("Read Failed. rc=%d client=%u[%u]\n", rc,
+ normal_i2c[client_num], client_num);
+ else
+ i2c_debug_print("Read Successful: count=%u val = 0x%x\n", (unsigned)count, *buf);
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_read);
+
+int maple_i2c_write_byte(unsigned char client_num, unsigned char offset, unsigned char val)
+{
+ u8 buf[2];
+ int rc;
+
+ i2c_debug_print("Write Byte: client=0x%x offset = 0x%x, val = 0x%x\n", normal_i2c[client_num], offset, val);
+
+ buf[0] = offset;
+ buf[1] = val;
+ rc = maple_i2c_send(client_num, buf, 2);
+
+ if (rc < 0)
+ i2c_debug_print("Write Byte Failed. rc=%d offset=0x%x val=0x%x client=%u[%u]\n",
+ rc, offset, val,
+ normal_i2c[client_num], client_num);
+ else
+ i2c_debug_print("Write Byte: offset=0x%x val=0x%x client=%u/%u\n",
+ offset, val,
+ normal_i2c[client_num], client_num);
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_write_byte);
+
+int maple_i2c_read_byte(unsigned char client_num, unsigned char offset, unsigned char *data)
+{
+ u8 o = offset;
+ u8 val;
+ int rc;
+
+ i2c_debug_print("Write Byte: client=0x%x offset = 0x%x, val = 0x%x\n", normal_i2c[client_num], offset, val);
+
+ rc = maple_i2c_read_with_offset(client_num, &o, 1, &val, 1);
+
+ if (rc < 0)
+ i2c_debug_print("Read Byte Failed. rc=%d client=%u[%u]\n", rc,
+ normal_i2c[client_num], client_num);
+ else
+ {
+ *data = val;
+ i2c_debug_print("Read Byte: client=0x%x offset = 0x%x, val = 0x%x\n",
+ normal_i2c[client_num], offset, *data);
+ }
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_read_byte);
+
+
+int maple_i2c_write_word(unsigned char client_num, unsigned char offset, unsigned short val)
+{
+ u8 buf[3];
+ int rc;
+
+ i2c_debug_print("Write Word: offset = 0x%x, val = 0x%x\n", offset, val);
+
+ /* The offset to be written should be the first byte in the I2C write */
+ buf[0] = offset;
+ buf[1] = (char)(val&0xFF);
+ buf[2] = (char)(val>>8);
+ rc = maple_i2c_send(client_num, buf, sizeof(buf));
+
+ if (rc < 0)
+ i2c_debug_print("Write Word Failed. rc=%d offset=0x%x val=0x%x, client=%u[%u]\n",
+ rc, offset, val,
+ normal_i2c[client_num], client_num);
+ else
+ i2c_debug_print("Write Word: offset=0x%x val=0x%x, client=%u[%u]\n",
+ offset, val,
+ normal_i2c[client_num], client_num);
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_write_word);
+
+int maple_i2c_read_word(unsigned char client_num, unsigned char offset, unsigned short *data)
+{
+ u8 o = offset;
+ u8 buf[2];
+ int rc;
+
+ rc = maple_i2c_read_with_offset(client_num, &o, 1, buf, sizeof(buf));
+
+ if (rc < 0)
+ i2c_debug_print("Read Word Failed. rc=%d offset=0x%x client=%u[%u]\n",
+ rc, offset,
+ normal_i2c[client_num], client_num);
+ else
+ {
+ *data = (buf[1]<<8) | buf[0]; /* I2C data is LE */
+ i2c_debug_print("Read Word: offset = 0x%x, val = 0x%x client=%u[%u]\n",
+ offset, *data,
+ normal_i2c[client_num], client_num);
+ }
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_read_word);
+
+
+int maple_i2c_write_reg(unsigned char client_num, unsigned char offset, int val)
+{
+ u8 buf[5];
+ int rc;
+
+ i2c_debug_print("Write Register: offset = 0x%x, val = 0x%x\n", offset, val);
+
+ /* Set the buf[0] to be the offset for write operation */
+ buf[0] = offset;
+
+ /* On the I2C bus, LS Byte should go first */
+ buf[1] = val & 0xff;
+ buf[2] = (val >> 8) & 0xff;
+ buf[3] = (val >> 16) & 0xff;
+ buf[4] = (val >> 24) & 0xff;
+ rc = maple_i2c_send(client_num, buf, sizeof(buf));
+
+ if (rc < 0)
+ i2c_debug_print("Write Reg Failed. rc=%d offset=0x%x val=0x%x client=%u[%u]\n",
+ rc, offset, val,
+ normal_i2c[client_num], client_num);
+ else
+ i2c_debug_print("Write Reg Successful. offset=0x%x val=0x%x client=%u[%u]\n",
+ offset, val,
+ normal_i2c[client_num], client_num);
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_write_reg);
+
+
+int maple_i2c_read_reg(unsigned char client_num, unsigned char offset, unsigned int *data)
+{
+ u8 o = offset;
+ u8 buf[4];
+ int rc;
+
+ rc = maple_i2c_read_with_offset(client_num, &o, 1, buf, sizeof(buf));
+
+ if (rc < 0)
+ i2c_debug_print("Read Reg Failed. rc=%d offset=0x%x client=%u[%u]\n",
+ rc, offset,
+ normal_i2c[client_num], client_num);
+ else
+ {
+ *data = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); /* LS byte is transferred first */
+ i2c_debug_print("Read Register: client=0x%x offset = 0x%x, val = 0x%x\n", normal_i2c[client_num], offset, *data);
+ }
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_read_reg);
+
+
+int maple_i2c_write_fpga(unsigned char client_num, unsigned int offset, unsigned int val)
+{
+ u8 buf[8];
+ int rc;
+
+ bcm_access_fpga();
+
+ i2c_debug_print("Write fpga: offset = 0x%x, val = 0x%x\n", offset, val);
+
+ /* Set the offset for write operation */
+ // offset = swab32(offset);
+ memcpy(&buf[0], (char*)&offset, 4);
+
+ /* On the I2C bus, LS Byte should go first */
+ // val = swab32(val);
+ memcpy(&buf[4], (char*)&val, 4);
+
+ rc = maple_i2c_send(client_num, buf, sizeof(buf));
+
+ if (rc < 0)
+ i2c_debug_print("Write FPGA Failed. rc=%d offset=0x%x val=0x%x client=%u[%u]\n",
+ rc, offset, val,
+ normal_i2c[client_num], client_num);
+ else
+ i2c_debug_print("Write FPGA: offset=0x%x val=0x%x client=%u[%u]\n",
+ offset, val,
+ normal_i2c[client_num], client_num);
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_write_fpga);
+
+int maple_i2c_read_fpga(unsigned char client_num, unsigned int offset, unsigned int *data)
+{
+ u8 obuf[4];
+ u8 buf[4];
+ int rc;
+
+ bcm_access_fpga();
+
+ /* FPGA expects 4 byte offset in BIG ENDIAN format */
+ obuf[0] = (offset >> 24) & 0xff;
+ obuf[1] = (offset >> 16) & 0xff;
+ obuf[2] = (offset >> 8) & 0xff;
+ obuf[3] = offset & 0xff;
+ rc = maple_i2c_read_with_offset(client_num, obuf, sizeof(obuf), buf, sizeof(buf));
+
+ if (rc < 0)
+ i2c_debug_print("Read FPGA Failed. rc=%d offset=0x%x client=%u[%u]\n",
+ rc, offset,
+ normal_i2c[client_num], client_num);
+ else
+ {
+ *data = buf[3] | (buf[2] << 8) | (buf[1] << 16) | (buf[0] << 24); /* MS byte is transferred first */
+ i2c_debug_print("Read FPGA: offset = 0x%x, val = 0x%x %02x %02x %02x %02x client=%u[%u]\n",
+ offset, *data, buf[0], buf[1], buf[2], buf[3],
+ normal_i2c[client_num], client_num);
+ }
+ return rc;
+}
+EXPORT_SYMBOL(maple_i2c_read_fpga);
+
+enum client_num maple_i2c_get_client(u32 addr)
+{
+ enum client_num i = 0;
+ while (i < SLAVE_NUM_OF_SLAVES)
+ {
+ if (pclient_data_ar[i])
+ {
+ if (slave_valid[i] && pclient_data_ar[i]->client.addr == addr)
+ {
+ break;
+ }
+ }
+ i++;
+ }
+ return i;
+}
+EXPORT_SYMBOL(maple_i2c_get_client);
+
+static int dev_change(u32 addr)
+{
+ enum client_num i = maple_i2c_get_client(addr);
+
+ if (i < SLAVE_NUM_OF_SLAVES)
+ {
+ i2c_client_num = i;
+ i2c_debug_print("Slave was set successfully i %d, addr 0x%x\n", i, addr);
+ }
+ else
+ {
+ i2c_debug_print("Failed to set slave i %d, addr 0x%x\n", i, addr);
+ }
+
+ return 0;
+}
+
+static void bcm_access_fpga(void)
+{
+ static int access_enabled;
+ int fpga_client_num = maple_i2c_get_client(I2C_SW1_I2C_ADDR);
+ uint8_t b;
+
+ if (access_enabled)
+ return;
+ b = 4;
+ maple_i2c_write(fpga_client_num, &b, 1);
+ access_enabled = 1;
+}
+#define BCM_FPGA_REG_RESETS 0x2
+#define BCM_FPGA_REG_FPGA_VERSION 0x0
+/* 1 = out of reset bcm_board_config_reset_value */
+void reset_maple(int bit,int param)
+{
+ int fpga_client_num = maple_i2c_get_client(FPGA_I2C_ADDR);
+ int sw_client_num = maple_i2c_get_client(I2C_SW0_I2C_ADDR);
+ uint8_t b = 1;
+ uint32_t reset_values;
+
+ maple_i2c_write(sw_client_num, &b, 1);
+
+ /* Read-modify-write so we can set only the relevant bit */
+ maple_i2c_read_fpga(fpga_client_num, BCM_FPGA_REG_RESETS, &reset_values);
+
+ if (param)
+ reset_values |= 1 << bit;
+ else
+ reset_values &= ~(1 << bit);
+ maple_i2c_write_fpga(fpga_client_num, BCM_FPGA_REG_RESETS, reset_values);
+}
+EXPORT_SYMBOL(reset_maple);
+
+/* Calls the appropriate function based on user command */
+static int exec_command(const char *buf, size_t count)
+{
+#define MAX_ARGS 4
+#define MAX_ARG_SIZE 32
+ int i, argc = 0, val = 0;
+ char cmd;
+ u32 offset = 0;
+ char arg[MAX_ARGS][MAX_ARG_SIZE];
+#define LOG_WR_KBUF_SIZE 128
+ char kbuf[LOG_WR_KBUF_SIZE];
+
+ if ((count > LOG_WR_KBUF_SIZE-1) || (copy_from_user(kbuf, buf, count) != 0))
+ return -EFAULT;
+ kbuf[count]=0;
+ argc = sscanf(kbuf, "%c %s %s %s %s", &cmd, arg[0], arg[1], arg[2], arg[3]);
+
+ if (argc < 1)
+ {
+ printk("Need at-least 2 arguments\n");
+ return -EFAULT;
+ }
+
+ for (i=0; i<MAX_ARGS; ++i) {
+ arg[i][MAX_ARG_SIZE-1] = '\0';
+ }
+ offset = (u32)simple_strtoul(arg[0], NULL, 0);
+ if (argc == 3)
+ val = (int)simple_strtoul(arg[1], NULL, 0);
+
+ switch (cmd)
+ {
+ case 'm':
+ reset_maple(0,offset); // maple out of reset(1) | reset (0)
+ break;
+ case 'k':
+ reset_maple(4,offset); // katana2 out of reset(1) | reset (0)
+ break;
+ case 'b':
+ if (argc == 3)
+ maple_i2c_write_byte(i2c_client_num, (u8)offset, (u8)val);
+ else
+ {
+ u8 data;
+ maple_i2c_read_byte(i2c_client_num, (u8)offset, &data);
+ printk("client 0x%x, offset 0x%x, data=0x%x\n", normal_i2c[i2c_client_num], offset, data);
+ }
+ break;
+
+ case 's':
+ if (argc == 2)
+ {
+ u8 data = (u8)offset;
+ maple_i2c_write(i2c_client_num, &data, 1);
+ }
+ else
+ {
+ u8 data = offset;
+ maple_i2c_read(i2c_client_num, &data, 1);
+ printk("client 0x%x, data=0x%x\n", normal_i2c[i2c_client_num], data);
+ }
+ break;
+
+ case 'w':
+ if (argc == 3)
+ maple_i2c_write_word(i2c_client_num, (u8)offset, (u16)val);
+ else
+ {
+ u16 data;
+ maple_i2c_read_word(i2c_client_num, (u8)offset, &data);
+ printk("client 0x%x, offset 0x%x, data=0x%x\n", normal_i2c[i2c_client_num], offset, data);
+ }
+ break;
+
+ case 'd':
+ if (argc == 3)
+ maple_i2c_write_reg(i2c_client_num, (u8)offset, val);
+ else
+ {
+ u32 data;
+ maple_i2c_read_reg(i2c_client_num, (u8)offset, &data);
+ printk("client 0x%x, offset 0x%x, data=0x%x\n", normal_i2c[i2c_client_num], offset, data);
+ }
+ break;
+
+ case 'f':
+ if (argc == 3)
+ maple_i2c_write_fpga(i2c_client_num, offset, val);
+ else
+ {
+ u32 data;
+ maple_i2c_read_fpga(i2c_client_num, offset, &data);
+ printk("client 0x%x, offset 0x%x, data=0x%x\n", normal_i2c[i2c_client_num], offset, data);
+ }
+ break;
+
+ case 'c':
+ dev_change(offset);
+ break;
+
+ default:
+ printk("Invalid command.\n Valid commands:\n"
+ " Change I2C Addr: c addr\n"
+ " Write Reg: d offset val\n"
+ " Read Reg: d offset\n"
+ " Write Word: w offset val\n"
+ " Read Word: w offset\n"
+ " Write Byte: b offset val\n"
+ " Read Byte: b offset\n"
+ " Write fpga: f offset val\n"
+ " Read fpga: f offset\n"
+ " Write to switch: s val (one byte)\n"
+ " Read from switch:s\n"
+ " Maple: m <0|1>\n"
+ " Katana2: k <0|1>\n"
+ );
+ break;
+ }
+ return count;
+}
+
+
+
+/* Read Function of PROCFS attribute "maple_i2c/test" */
+static ssize_t maple_i2c_proc_test_read(struct file *f, char *buf, size_t count,
+ loff_t *pos)
+{
+ printk(" Usage: echo command > "
+ " /proc/maple_i2c/test\n");
+ printk(" supported commands:\n"
+ " Change I2C Addr: c addr\n"
+ " Write Reg: d offset val\n"
+ " Read Reg: d offset\n"
+ " Write Word: w offset val\n"
+ " Read Word: w offset\n"
+ " Write Byte: b offset val\n"
+ " Read Byte: b offset\n"
+ " Write fpga: f offset val\n"
+ " Read fpga: f offset\n"
+ " Write to switch: s val (one byte)\n"
+ " Read from switch:s\n"
+ );
+ return 0;
+}
+
+/* Write Function of PROCFS attribute "maple_i2c/test" */
+static ssize_t maple_i2c_proc_test_write(struct file *f, const char *buf,
+ size_t count, loff_t *pos)
+{
+ return exec_command(buf, count);
+}
+
+/* Return 0 if detection is successful, -ENODEV otherwise */
+static int maple_i2c_dev_detect(struct i2c_client *client, struct i2c_board_info *info)
+{
+ i2c_debug_print("detecting i2c device 0x%x\n", client->addr);
+
+ /* TODO: detection and identification */
+
+ strcpy(info->type, "maple_i2c");
+ info->flags = 0;
+ return 0;
+}
+
+static struct file_operations maple_i2c_fops =
+{
+ read: maple_i2c_proc_test_read,
+ write: maple_i2c_proc_test_write
+};
+
+static int maple_i2c_dev_create_proc(void)
+{
+ i2c_proc_dir = proc_mkdir(PROC_DIR_NAME, NULL);
+ if (!i2c_proc_dir)
+ {
+ i2c_debug_print("fail to create proc dir\n");
+ return -ENOMEM;
+ }
+
+ i2c_proc_entry = create_proc_entry(PROC_ENTRY_NAME, 0, i2c_proc_dir);
+ if (!i2c_proc_entry)
+ {
+ remove_proc_entry(PROC_DIR_NAME, NULL);
+ return -ENOMEM;
+ }
+
+ i2c_proc_entry->proc_fops = &maple_i2c_fops;
+
+ return 0;
+}
+
+static int maple_i2c_chrdev_open(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static int maple_i2c_chrdev_release(struct inode *inode, struct file *filp)
+{
+ return 0;
+}
+
+static long maple_i2c_chrdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ int linux_rc = 0;
+ int rc;
+ maple_i2c_ioctl_param params;
+
+ /* don't even decode wrong cmds: better returning ENOTTY than EFAULT */
+ if (_IOC_TYPE(cmd) != MAPLE_I2C_IOCTL_MAGIC)
+ return -ENOTTY;
+
+ /*
+ * the type is a bitmask, and VERIFY_WRITE catches R/W
+ * transfers. Note that the type is user-oriented, while
+ * verify_area is kernel-oriented, so the concept of "read" and
+ * "write" is reversed
+ */
+ if (_IOC_DIR(cmd) & _IOC_READ)
+ linux_rc = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));
+ else if (_IOC_DIR(cmd) & _IOC_WRITE)
+ linux_rc = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));
+ if (linux_rc)
+ return -EFAULT;
+
+ switch (cmd)
+ {
+ case MAPLE_I2C_IOCTL_OP_DEV_CHANGE:
+ {
+ linux_rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (linux_rc < 0)
+ break;
+ return dev_change(params.addr);
+ }
+ break;
+ case MAPLE_I2C_IOCTL_OP_DEV_WRITE:
+ {
+ linux_rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (linux_rc < 0)
+ break;
+ switch (params.count)
+ {
+ case 8:
+ return maple_i2c_write_byte(i2c_client_num, params.addr, params.val);
+ case 16:
+ return maple_i2c_write_word(i2c_client_num, params.addr, params.val);
+ case 32:
+ return maple_i2c_write_reg(i2c_client_num, params.addr, params.val);
+ default:
+ return -EINVAL;
+ }
+ }
+ break;
+ case MAPLE_I2C_IOCTL_OP_DEV_READ:
+ {
+ unsigned char b;
+ unsigned short w;
+ unsigned int r;
+
+ linux_rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (linux_rc < 0)
+ break;
+ switch (params.count)
+ {
+ case 8:
+ linux_rc = maple_i2c_read_byte(i2c_client_num, params.addr, &b);
+ if (linux_rc < 0)
+ break;
+ params.val = b;
+ break;
+ case 16:
+ linux_rc = maple_i2c_read_word(i2c_client_num, params.addr, &w);
+ if (linux_rc < 0)
+ break;
+ params.val = w;
+ break;
+ case 32:
+ linux_rc = maple_i2c_read_reg(i2c_client_num, params.addr, &r);
+ if (linux_rc < 0)
+ break;
+ params.val = r;
+ break;
+ default:
+ return -EINVAL;
+ }
+ if (linux_rc < 0)
+ break;
+ return copy_to_user((char *)arg, (char *)¶ms, sizeof(params));
+ }
+ case MAPLE_I2C_IOCTL_OP_SWITCH_WRITE:
+ {
+ char b;
+
+ linux_rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (linux_rc < 0)
+ break;
+ b = params.val;
+ return maple_i2c_write(i2c_client_num, &b, 1);
+ }
+ case MAPLE_I2C_IOCTL_OP_SWITCH_READ:
+ {
+ char b;
+
+ linux_rc = maple_i2c_read(i2c_client_num, &b, 1);
+ if (linux_rc < 0)
+ break;
+ params.val = b;
+ return copy_to_user((char *)arg, (char *)¶ms, sizeof(params));
+ }
+ case MAPLE_I2C_IOCTL_OP_FPGA_WRITE:
+ {
+ linux_rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (linux_rc < 0)
+ break;
+ return maple_i2c_write_fpga(i2c_client_num, params.addr, params.val);
+ }
+ case MAPLE_I2C_IOCTL_OP_FPGA_READ:
+ {
+ linux_rc = copy_from_user((char *)¶ms, (char *)arg, sizeof(params));
+ if (linux_rc < 0)
+ break;
+ linux_rc = maple_i2c_read_fpga(i2c_client_num, params.addr, ¶ms.val);
+ if (linux_rc < 0)
+ break;
+ return copy_to_user((char *)arg, (char *)¶ms, sizeof(params));
+ }
+ default:
+ rc = -ENOTTY;
+ break;
+ }
+
+ return linux_rc;
+}
+
+static ssize_t maple_i2c_chrdev_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *f_pos)
+{
+ return 0;
+}
+
+static struct file_operations maple_i2c_chrdev_fops =
+{
+ .owner = THIS_MODULE,
+ .open = maple_i2c_chrdev_open,
+ .release = maple_i2c_chrdev_release,
+ .write = maple_i2c_chrdev_write,
+ .unlocked_ioctl = maple_i2c_chrdev_ioctl
+};
+
+static struct cdev maple_i2c_chrdev_cdev;
+
+static int maple_i2c_dev_create_chrdev(void)
+{
+ dev_t dev = MKDEV(maple_i2c_chrdev_major, 0);
+ int linux_rc;
+
+ is_chrdev_reg = 0;
+ is_cdev_add = 0;
+ /*
+ * Register your major, and accept a dynamic number.
+ */
+ if (!maple_i2c_chrdev_major)
+ return -1;
+ linux_rc = register_chrdev_region(dev, 0, "maple_i2c");
+ if (linux_rc < 0)
+ {
+ i2c_debug_print("register_chrdev_region()->%d\n", linux_rc);
+ return -EIO;
+ }
+ is_chrdev_reg = 1;
+
+ cdev_init(&maple_i2c_chrdev_cdev, &maple_i2c_chrdev_fops);
+ linux_rc = cdev_add(&maple_i2c_chrdev_cdev, dev, 1);
+ if (linux_rc < 0)
+ {
+ i2c_debug_print("cdev_add()->%d\n", linux_rc);
+ return -EIO;
+ }
+ is_cdev_add = 1;
+
+ return 0;
+}
+
+static int maple_i2c_dev_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+ int err = 0;
+ struct maple_i2c_data *pclient_data;
+
+ i2c_debug_print("!!!! i2c device 0x%x probe\n", client->addr);
+
+ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+ goto exit;
+
+ if (!(pclient_data = kzalloc(sizeof(struct maple_i2c_data), GFP_KERNEL)))
+ {
+ err = -ENOMEM;
+ goto exit;
+ }
+
+ pclient_data->client.addr = client->addr;
+ pclient_data->client.adapter = client->adapter;
+ pclient_data->client.driver = client->driver;
+ pclient_data->client.flags = client->flags;
+
+ i2c_set_clientdata(client, pclient_data);
+
+ switch(client->addr)
+ {
+ case I2C_SW0_I2C_ADDR:
+ pclient_data_ar[SLAVE_SWITCH_70] = pclient_data;
+ slave_valid[SLAVE_SWITCH_70] = 1;
+ break;
+ case I2C_SW1_I2C_ADDR:
+ pclient_data_ar[SLAVE_SWITCH_71] = pclient_data;
+ slave_valid[SLAVE_SWITCH_71] = 1;
+ break;
+ case I2C_SW2_I2C_ADDR:
+ pclient_data_ar[SLAVE_SWITCH_72] = pclient_data;
+ slave_valid[SLAVE_SWITCH_72] = 1;
+ break;
+ case I2C_SW3_I2C_ADDR:
+ pclient_data_ar[SLAVE_SWITCH_73] = pclient_data;
+ slave_valid[SLAVE_SWITCH_73] = 1;
+ break;
+ case I2C_SW4_I2C_ADDR:
+ pclient_data_ar[SLAVE_SWITCH_74] = pclient_data;
+ slave_valid[SLAVE_SWITCH_74] = 1;
+ break;
+ case SFP_I2C_ADDR1:
+ pclient_data_ar[SLAVE_SFP_50] = pclient_data;
+ slave_valid[SLAVE_SFP_50] = 1;
+ break;
+ case SFP_I2C_ADDR2:
+ pclient_data_ar[SLAVE_SFP_51] = pclient_data;
+ slave_valid[SLAVE_SFP_51] = 1;
+ break;
+ case FPGA_I2C_ADDR:
+ pclient_data_ar[SLAVE_FPGA_40] = pclient_data;
+ slave_valid[SLAVE_FPGA_40] = 1;
+ break;
+ case PON_DPLL_I2C_ADDR:
+ pclient_data_ar[SLAVE_PON_DPLL_68] = pclient_data;
+ slave_valid[SLAVE_PON_DPLL_68] = 1;
+ break;
+ case PM_DPLL_I2C_ADDR:
+ pclient_data_ar[SLAVE_PM_DPLL_6A] = pclient_data;
+ slave_valid[SLAVE_PM_DPLL_6A] = 1;
+ break;
+ case CXP_R_I2C_ADDR:
+ pclient_data_ar[SLAVE_CXP_R_54] = pclient_data;
+ slave_valid[SLAVE_CXP_R_54] = 1;
+ break;
+ case PCIE_SW_I2C_ADDR:
+ pclient_data_ar[SLAVE_PCIE_SW_3C] = pclient_data;
+ slave_valid[SLAVE_PCIE_SW_3C] = 1;
+ break;
+ default:
+ i2c_debug_print("%s client addr out of range 0x%x\n", __FUNCTION__, client->addr);
+ goto exit_kfree;
+ }
+
+ /* Create only once */
+ if (i2c_proc_entry == NULL)
+ {
+ if (maple_i2c_dev_create_proc() < 0)
+ goto exit_kfree;
+ }
+ if (!is_cdev_add)
+ {
+ if (maple_i2c_dev_create_chrdev() < 0)
+ goto exit_kfree;
+ }
+ ++i2c_num_clients;
+
+ return 0;
+
+exit_kfree:
+ kfree(pclient_data);
+exit:
+ return err;
+}
+
+static int maple_i2c_dev_remove(struct i2c_client *client)
+{
+ kfree(i2c_get_clientdata(client));
+ --i2c_num_clients;
+ if (!i2c_num_clients)
+ {
+ if (i2c_proc_entry != NULL)
+ {
+ remove_proc_entry(PROC_ENTRY_NAME, i2c_proc_dir);
+ i2c_proc_entry = NULL;
+ }
+ if (i2c_proc_dir != NULL)
+ {
+ remove_proc_entry(PROC_DIR_NAME, NULL);
+ i2c_proc_dir = NULL;
+ }
+ if (is_cdev_add)
+ {
+ cdev_del(&maple_i2c_chrdev_cdev);
+ is_cdev_add = 0;
+ }
+ if (is_chrdev_reg)
+ {
+ unregister_chrdev_region(MKDEV(maple_i2c_chrdev_major, 0), 1);
+ is_chrdev_reg = 0;
+ }
+ }
+
+ return 0;
+}
+
+static struct i2c_driver maple_i2c_dev_driver = {
+ .class = ~0,
+ .driver = {
+ .name = "maple_i2c",
+ },
+ .probe = maple_i2c_dev_probe,
+ .remove = maple_i2c_dev_remove,
+ .id_table = maple_i2c_id_table,
+ .detect = maple_i2c_dev_detect,
+ .address_list = normal_i2c,
+};
+
+module_i2c_driver(maple_i2c_dev_driver);
+
+MODULE_DESCRIPTION("maple i2c devices");
+MODULE_LICENSE("GPL");
+
diff --git a/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs.h b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs.h
new file mode 100644
index 0000000..ad0edaa
--- /dev/null
+++ b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs.h
@@ -0,0 +1,226 @@
+/*
+<: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_I2C_DEVS_H_
+#define _BCMOLT_I2C_DEVS_H_
+
+/* When inserting the module (with insmod) onlt the I2C switch devices (I2C_SWX_I2C_ADDR)
+ will be automatically detected, and therefore will be probed.
+ Probing all other devices can be done after inerting the module via sysfs.
+ for example, in order to probe FPGA device, the following line should be applied:
+ -- echo maple_i2c FPGA_I2C_ADDR > /sys/bus/i2c/devices/i2c-0/new_device --
+*/
+enum client_num
+{
+ SLAVE_SWITCH_70 = 0,
+ SLAVE_SWITCH_71 = 1,
+ SLAVE_SWITCH_72 = 2,
+ SLAVE_SWITCH_73 = 3,
+ SLAVE_SWITCH_74 = 4,
+ SLAVE_SFP_50 = 5,
+ SLAVE_SFP_51 = 6,
+ SLAVE_FPGA_40 = 7,
+ SLAVE_PON_DPLL_68 = 8,
+ SLAVE_PM_DPLL_6A = 9,
+ SLAVE_CXP_R_54 = 10,
+ SLAVE_PCIE_SW_3C = 11,
+ SLAVE_NUM_OF_SLAVES
+};
+
+
+/*****************************************************************
+ maple_i2c_write
+
+ DESCRIPTION:
+ Writes serially data to I2C device
+
+ PARAMETERS:
+ client num - The client to write to.
+ buf - The buffer to write.
+ count - Number of bytes to write
+
+ OUTPUT:
+ The number of bytes that were written, when fails return negative number
+********************************************************************/
+ssize_t maple_i2c_write(unsigned char client_num, char *buf, size_t count);
+
+/*****************************************************************
+ maple_i2c_read
+
+ DESCRIPTION:
+ Read serially data from I2C device
+
+ PARAMETERS:
+ client num - The client to write to.
+ buf - The buffer to read to.
+ count - Number of bytes to read
+
+ OUTPUT:
+ The number of bytes that were read, when fails return negative number
+********************************************************************/
+ssize_t maple_i2c_read(unsigned char client_num, char *buf, size_t count);
+
+/*****************************************************************
+ maple_i2c_write_byte
+
+ DESCRIPTION:
+ Write byte to I2C device
+
+ PARAMETERS:
+ client num - The client to write to.
+ offset - The offset to write to.
+ val - Tha data to write.
+
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_write_byte(unsigned char client_num, unsigned char offset, unsigned char val);
+
+/*****************************************************************
+ maple_i2c_read_byte
+
+ DESCRIPTION:
+ Read byte from I2C device
+
+ PARAMETERS:
+ client num - The client to read from.
+ offset - The offset to read from.
+ data - the read value is written to this pointer.
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_read_byte(unsigned char client_num, unsigned char offset, unsigned char* data);
+
+/*****************************************************************
+ maple_i2c_write_word
+
+ DESCRIPTION:
+ Write 16 bit word to I2C device
+
+ PARAMETERS:
+ client num - The client to write to.
+ offset - The offset to write to.
+ val - Tha data to write.
+
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_write_word(unsigned char client_num, unsigned char offset, unsigned short val);
+
+/*****************************************************************
+ maple_i2c_read_word
+
+ DESCRIPTION:
+ Read 16 bit word from I2C device
+
+ PARAMETERS:
+ client num - The client to read from.
+ offset - The offset to read from.
+ data - the read value is written to this pointer.
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_read_word(unsigned char client_num, unsigned char offset, unsigned short* data);
+
+/*****************************************************************
+ maple_i2c_write_reg
+
+ DESCRIPTION:
+ Write 32 bit register to I2C device
+
+ PARAMETERS:
+ client num - The client to write to.
+ offset - The offset to write to.
+ val - Tha data to write.
+
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_write_reg(unsigned char client_num, unsigned char offset, int val);
+
+/*****************************************************************
+ maple_i2c_read_reg
+
+ DESCRIPTION:
+ Read 32 bit word from I2C device
+
+ PARAMETERS:
+ client num - The client to read from.
+ offset - The offset to read from.
+ data - the read value is written to this pointer.
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_read_reg(unsigned char client_num, unsigned char offset, unsigned int* data);
+
+/*****************************************************************
+ maple_i2c_write_fpga
+
+ DESCRIPTION:
+ Write 32 bit register to I2C fpga device
+
+ PARAMETERS:
+ client num - The client to write to.
+ offset - The offset to write to.
+ val - Tha data to write.
+
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_write_fpga(unsigned char client_num, unsigned int offset, unsigned int val);
+
+/*****************************************************************
+ maple_i2c_read_fpga
+
+ DESCRIPTION:
+ Read 32 bit word from I2C fpga device
+
+ PARAMETERS:
+ client num - The client to read from.
+ offset - The offset to read from.
+ data - the read value is written to this pointer.
+ OUTPUT:
+ 0 on success, -1 on failure.
+********************************************************************/
+int maple_i2c_read_fpga(unsigned char client_num, unsigned int offset, unsigned int* data);
+
+/*****************************************************************
+ maple_i2c_get_client
+
+ DESCRIPTION:
+ Gets an I2C client number from an address
+
+ PARAMETERS:
+ addr - The address of the client.
+ OUTPUT:
+ The client number for this client, or SLAVE_NUM_OF_SLAVES on failure.
+********************************************************************/
+enum client_num maple_i2c_get_client(unsigned int addr);
+
+#endif /* _MAPLE_I2C_DEVS_H_ */
diff --git a/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs_addr.h b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs_addr.h
new file mode 100644
index 0000000..f1a9a2c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs_addr.h
@@ -0,0 +1,50 @@
+/*
+<: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_I2C_DEVS_ADDR_H_
+#define _BCMOLT_I2C_DEVS_ADDR_H_
+
+BCM_I2C_DEV_ADDR_START
+BCM_I2C_DEV_ADDR(I2C_SW0_I2C_ADDR, "sw0", 0x70)
+BCM_I2C_DEV_ADDR(I2C_SW1_I2C_ADDR, "sw1", 0x71)
+BCM_I2C_DEV_ADDR(I2C_SW2_I2C_ADDR, "sw2", 0x72)
+BCM_I2C_DEV_ADDR(I2C_SW3_I2C_ADDR, "sw3", 0x73)
+BCM_I2C_DEV_ADDR(I2C_SW4_I2C_ADDR, "sw4", 0x74)
+BCM_I2C_DEV_ADDR(SFP_I2C_ADDR1, "sfp1", 0x50)
+BCM_I2C_DEV_ADDR(SFP_I2C_ADDR2, "sfp2", 0x51)
+BCM_I2C_DEV_ADDR(FPGA_I2C_ADDR, "fpga", 0x40)
+BCM_I2C_DEV_ADDR(PON_DPLL_I2C_ADDR, "pon_dpll", 0x68)
+BCM_I2C_DEV_ADDR(PM_DPLL_I2C_ADDR, "pm_dpll", 0x6a)
+BCM_I2C_DEV_ADDR(CXP_T_I2C_ADDR, "cxp_t", 0x50)
+BCM_I2C_DEV_ADDR(CXP_R_I2C_ADDR, "cxp_r", 0x54)
+BCM_I2C_DEV_ADDR(PCIE_SW_I2C_ADDR, "pcie_sw", 0x3c)
+BCM_I2C_DEV_ADDR_END
+
+#endif
+
diff --git a/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs_ioctl.h b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs_ioctl.h
new file mode 100644
index 0000000..e15f71a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/i2c/bcmolt_i2c_devs_ioctl.h
@@ -0,0 +1,24 @@
+#ifndef _BCMOLT_I2C_DEVS_IOCTL_H_
+#define _BCMOLT_I2C_DEVS_IOCTL_H_
+
+#include <linux/ioctl.h>
+
+typedef struct
+{
+ uint32_t count;
+ uint32_t addr;
+ uint32_t val;
+} maple_i2c_ioctl_param;
+
+#define MAPLE_I2C_IOCTL_MAGIC 'I'
+
+#define MAPLE_I2C_IOCTL_OP_DEV_CHANGE _IOW(MAPLE_I2C_IOCTL_MAGIC, 1, maple_i2c_ioctl_param)
+#define MAPLE_I2C_IOCTL_OP_DEV_WRITE _IOW(MAPLE_I2C_IOCTL_MAGIC, 2, maple_i2c_ioctl_param)
+#define MAPLE_I2C_IOCTL_OP_DEV_READ _IOWR(MAPLE_I2C_IOCTL_MAGIC, 3, maple_i2c_ioctl_param)
+#define MAPLE_I2C_IOCTL_OP_SWITCH_WRITE _IOW(MAPLE_I2C_IOCTL_MAGIC, 4, maple_i2c_ioctl_param)
+#define MAPLE_I2C_IOCTL_OP_SWITCH_READ _IOR(MAPLE_I2C_IOCTL_MAGIC, 5, maple_i2c_ioctl_param)
+#define MAPLE_I2C_IOCTL_OP_FPGA_WRITE _IOW(MAPLE_I2C_IOCTL_MAGIC, 6, maple_i2c_ioctl_param)
+#define MAPLE_I2C_IOCTL_OP_FPGA_READ _IOWR(MAPLE_I2C_IOCTL_MAGIC, 7, maple_i2c_ioctl_param)
+
+#endif
+
diff --git a/bcm68620_release/release/host_customized/ll_pcie/Makefile b/bcm68620_release/release/host_customized/ll_pcie/Makefile
new file mode 100755
index 0000000..db7aa7d
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/Makefile
@@ -0,0 +1,36 @@
+MOD_NAME = ll_pcie
+MOD_SUPPRESS_OS_DEP = y
+MOD_DEPS = board_selector
+
+ifeq ("$(RELEASE_BUILD)", "y")
+ EXTRA_CFLAGS += -I$(SRC_DIR) -I$(TOP_DIR)/host_customized/os_abstraction
+ EXTRA_CFLAGS += -I$(TOP_DIR)/host_customized/os_abstraction/linux -I$(TOP_DIR)/host_driver/config
+else
+ EXTRA_CFLAGS += -I$(SRC_DIR) -I$(TOP_DIR)/common/os_abstraction -I$(TOP_DIR)/host/config
+ EXTRA_CFLAGS += -I$(TOP_DIR)/common/os_abstraction/linux -I$(TOP_DIR)/host/os_abstraction/$(PLATFORM)
+endif
+
+ifeq ("$(ENABLE_TRACE)", "y")
+ MOD_DEFS += -DTX_ENABLE_EVENT_TRACE
+ EXTRA_CFLAGS += -I$(TOP_DIR)/common/drivers/maple/fld
+ ifeq ("$(DEBUG_TRACE_INIT)", "y")
+ MOD_DEFS += -DDEBUG_TRACE_INIT
+ endif
+endif
+
+ifeq ("$(OS_KERNEL)", "linux")
+ MOD_TYPE = linux_module
+ srcs = bcmolt_llpcie.c
+else
+ MOD_TYPE = lib
+endif
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+USE_LINT = yes
+
+
diff --git a/bcm68620_release/release/host_customized/ll_pcie/bcmolt_llpcie.c b/bcm68620_release/release/host_customized/ll_pcie/bcmolt_llpcie.c
new file mode 100755
index 0000000..4bb1507
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/bcmolt_llpcie.c
@@ -0,0 +1,1010 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ might use readl or ioread32
+*/
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/compiler.h>
+#include <linux/pci.h>
+#include <linux/pci_regs.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/proc_fs.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+#include <linux/gfp.h>
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <linux/spinlock.h>
+
+#ifdef TX_ENABLE_EVENT_TRACE
+#include <linux/ctype.h>
+#include <linux/file.h>
+#include <linux/fs.h>
+#include "bcm_fld_common.h"
+#endif
+#include <bcmolt_board_selector.h>
+#include "bcmolt_llpcie.h"
+
+#define DRV_NAME "maple"
+#define DRV_VERSION "1.0.3"
+
+#define BAR_REGS 0
+#define BAR_DDR 2
+#define BAR_SRAM 4
+/*
+bar 1 = 8 Mbyte register space
+bar 2 = 16 Mbyte DDR space
+bar 3 = 64 Kbyte SRAM space
+*/
+#define MAPLE_REGS_LENGTH 0x00800000
+#define MAPLE_DDR_LENGTH 0x01000000
+#define MAPLE_SRAM_LENGTH 0x00010000
+
+#ifdef TX_ENABLE_EVENT_TRACE
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_LO 0x064014U
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_HI 0x064018U
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_BASE_LIMIT 0x064074U
+#endif
+#define PCIE_REVISION_REGISTER_OFFSET 0x6406CU /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_REVISION */
+#define PCIE_STATUS_REGISTER_OFFSET 0x64068U /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_PCIE_STATUS */
+#define PCIE_HARD_DEBUG_REGISTER_OFFSET 0x64204U /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_HARD_DEBUG */
+#define PCIE_INT_STATUS_REGISTER_OFFSET 0x69400U /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_STATUS */
+#define PCIE_INT_CLEAR_MASK_OFFSET 0x6940CU /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_MASK_CLEAR */
+#define PCIE_INTR1_STATUS_REGISTER_OFFSET 0x69300U /* Interrupt Status Register */
+
+#define PCIE_MAPLE_VENDOR_ID 0x14E4 /* PCIE_CFG_TYPE0_EP_SUBSYSTEM_ID_VENDOR_ID */
+#define PCIE_MAPLE_DEVICE_ID 0x6862
+#define PCIE_MAPLE_6863_SKU_DEVICE_ID 0x6863
+#define PCIE_MAPLE_EPON_DEVICE_ID 0x5554
+
+#define MAPLE_DRIVER_NAME DRV_NAME " BCM68620 (Maple) PCI driver " DRV_VERSION
+
+struct proc_dir_entry *bcmolt_dir = NULL;
+static DEFINE_PCI_DEVICE_TABLE(maple_pci_tbl) =
+{ /* vendor_id, device_id, any, any */
+ {PCI_DEVICE(PCIE_MAPLE_VENDOR_ID, PCIE_MAPLE_DEVICE_ID)},
+ {PCI_DEVICE(PCIE_MAPLE_VENDOR_ID, PCIE_MAPLE_6863_SKU_DEVICE_ID)},
+ {PCI_DEVICE(PCIE_MAPLE_VENDOR_ID, PCIE_MAPLE_EPON_DEVICE_ID)},
+ {0}
+};
+MODULE_DEVICE_TABLE (pci, maple_pci_tbl);
+
+typedef struct
+{
+ bcm_ll_dev_info device;
+ spinlock_t lock;
+ int err_status;
+ int phylink;
+ int prev_datalink;
+ int datalink;
+ uint32_t deviceid;
+ unsigned int *traceaddr;
+ struct pci_dev *pdev;
+ int enabled;
+} maple_device_info;
+
+static int crt_device = 0;
+static bcm_ll_pcie_status_change callback;
+static bcmos_bool is_initialized = BCMOS_FALSE;
+
+static maple_device_info devices[MAPLE_MAX_DEVICES];
+//static irqreturn_t maple_interrupt (int irq, void *dev_instance);
+static maple_device_info *get_maple_pci_info(int crt);
+
+static int maple_write(struct file *file,const char *buffer,size_t count, void *data);
+static int maple_read(char *page, char **start, off_t off, int count, int *eof, void *data);
+
+/* Map bus/device to device_id */
+static int _pcie_bus_devfv_to_devid(int bus, int devfn)
+{
+ const bus_devfn_devid *map;
+ for (map = bcmolt_board_pci_map_table_get(); map && map->bus > 0; map++)
+ {
+ if (map->bus == bus && map->devfn == devfn)
+ {
+ return map->device;
+ }
+ }
+ /* Not found - use incremental mapping */
+ return crt_device;
+}
+
+/* procedure used by OS to connect Maple PCI to allocated memory */
+
+static int __devinit maple_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
+{
+ int rc;
+ volatile unsigned int readval;
+ maple_device_info *device_info = NULL;
+ int dev_id;
+ u32 val;
+
+ if (!pdev)
+ return 1;
+
+ dev_info(&pdev->dev,
+ "Bus = %d Slot = %d Vendor:device = 0x%04x:0x%04x revision = 0x%02x\n",
+ pdev->bus->number, pdev->devfn,
+ pdev->vendor, pdev->device, pdev->revision);
+
+ if (crt_device == MAPLE_MAX_DEVICES)
+ {
+ printk(" Maximum Maple devices already defined (%d)\n", MAPLE_MAX_DEVICES);
+ return -ENODEV;
+ }
+
+ dev_id = _pcie_bus_devfv_to_devid(pdev->bus->number, pdev->devfn);
+ ++crt_device;
+ device_info = &devices[dev_id];
+ memset(device_info, 0, sizeof(maple_device_info));
+
+ spin_lock_init(&device_info->lock);
+ device_info->deviceid = dev_id;
+ device_info->pdev = pdev;
+
+ /* Enable maple device on PCIe bus and fixup BARs.
+ * Without fixup, module unload/reload crashes with WRX host
+ * because PCI hotplug doesn't work and after unload/re-load
+ * linux believes that BARs are already set.
+ */
+ rc = bcm_ll_pcie_dev_enable(dev_id);
+ if (rc)
+ {
+ printk("Error pci_enable_device_mem = %d\n",rc);
+ goto err_out;
+ }
+
+ rc = pci_request_selected_regions(pdev, pci_select_bars(pdev, IORESOURCE_MEM), DRV_NAME);
+ if (rc)
+ goto err_out;
+
+ pci_set_master(pdev);
+ pci_save_state(pdev);
+
+ device_info->device.soc_regs_base = (unsigned long)pci_ioremap_bar(pdev, BAR_REGS);
+ device_info->device.soc_sram_base = (unsigned long)pci_ioremap_bar(pdev, BAR_SRAM);
+ device_info->device.soc_ddr_base = (unsigned long)pci_ioremap_bar(pdev, BAR_DDR);
+ device_info->device.soc_ddr_length = (uint32_t)pci_resource_len(pdev, BAR_DDR);
+ device_info->device.irq = pdev->irq;
+ pci_set_drvdata(pdev, device_info);
+
+ //rc = request_irq(device_info->device.irq, maple_interrupt, IRQF_SHARED, "maple-pcie", device_info);
+ if (!rc && device_info->device.soc_sram_base)
+ {
+ device_info->device.irq_connected = 1;
+ readval = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_REVISION_REGISTER_OFFSET));
+ printk("Card %d version major=%02x minor=%02x\n",device_info->deviceid,
+ ((readval & 0x0000ff00) >> 8),(readval & 0x000000ff));
+ printk("regs_start = 0x%lx\nddr_start = 0x%lx\nsram_start = 0x%lx\nddr_length = %d\n",
+ device_info->device.soc_regs_base,device_info->device.soc_ddr_base,
+ device_info->device.soc_sram_base, (int)device_info->device.soc_ddr_length);
+ pci_read_config_dword(pdev,PCI_BASE_ADDRESS_0,&val);
+ printk("BAR REGS = 0x%x\n",(unsigned int)val);
+ pci_read_config_dword(pdev,PCI_BASE_ADDRESS_2,&val);
+ printk("BAR DDR = 0x%x\n",(unsigned int)val);
+ pci_read_config_dword(pdev,PCI_BASE_ADDRESS_4,&val);
+ printk("BAR SRAM = 0x%x\n",(unsigned int)val);
+ readval = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET));
+ device_info->err_status = readval & 0x0000000f;
+ device_info->phylink = (readval >> 4) & 0x1;
+ device_info->datalink = (readval >> 5) & 0x1;
+ device_info->prev_datalink = device_info->datalink;
+ }
+ else
+ goto err_out;
+
+ return rc;
+
+err_out:
+ pci_disable_device (pdev);
+ memset(device_info, 0, sizeof(*device_info));
+ --crt_device;
+
+ return rc;
+}
+
+static void __devexit maple_pci_remove(struct pci_dev *pdev)
+{
+ int i;
+ maple_device_info *dev = pci_get_drvdata(pdev);
+
+ if (!dev)
+ return;
+
+ if (dev->device.irq_connected)
+ {
+ //free_irq(dev->device.irq, dev);
+ dev->device.irq_connected = 0;
+ }
+ if (callback)
+ {
+ for (i = 0; i < crt_device; i++)
+ {
+ if (devices[i].pdev == pdev)
+ {
+ callback(i, BCM_LL_PCIE_LINK_DOWN);
+ break;
+ }
+ }
+ }
+ pci_disable_device(pdev);
+ pci_release_regions(pdev);
+ pci_set_drvdata(pdev, NULL);
+ dev->device.soc_sram_base = 0;
+ dev->device.soc_regs_base = 0;
+ dev->pdev = NULL;
+}
+
+static struct pci_driver maple_pci_driver = {
+ .name = DRV_NAME,
+ .id_table = maple_pci_tbl,
+ .probe = maple_pci_probe,
+ .remove = __devexit_p(maple_pci_remove),
+};
+
+static maple_device_info *get_maple_pci_info(int crt)
+{
+ unsigned int readval=0;
+ maple_device_info *device;
+
+ if (crt >= BCMTR_MAX_OLTS)
+ return NULL;
+
+ device = &devices[crt];
+ if (device->device.soc_regs_base)
+ {
+ if (device->enabled)
+ {
+ readval = bcm_pci_read32((uint32_t *)(device->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET));
+ device->err_status = readval & 0x0000000f;
+ device->phylink = (readval >> 4) & 0x1;
+ device->datalink = (readval >> 5) & 0x1;
+ }
+ else
+ {
+ device->err_status = 0;
+ device->phylink = 0;
+ device->datalink = 0;
+ }
+ }
+ else
+ device = NULL;
+
+ return device;
+}
+
+#if 0
+static irqreturn_t maple_interrupt (int irq, void *dev_instance)
+{
+ volatile unsigned int value;
+ maple_device_info *device_info;
+ unsigned long flags;
+ int handled = IRQ_NONE;
+ uint32_t device;
+
+ spin_lock_irqsave(&device_info->lock, flags);
+ value = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_INT_STATUS_REGISTER_OFFSET));
+ if (value)
+ {
+ if (device_info->datalink != device_info->prev_datalink)
+ {
+ if (device_info->datalink == BCM_LL_PCIE_LINK_UP)
+ printk("Device=%d : Link is up !!!\n", device);
+ else
+ {
+ printk("Device=%d : Link is down !!!\n", device);
+ printk("phy status = 0x%x error status = 0x%x\n", device_info->phylink, device_info->err_status);
+ }
+ device_info->prev_datalink = device_info->datalink;
+ if (callback)
+ callback(device, device_info->datalink);
+ }
+ value = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_INTR1_STATUS_REGISTER_OFFSET));
+ if (!value)
+ handled = IRQ_HANDLED;
+ }
+ spin_unlock_irqrestore(&device_info->lock, flags);
+
+ return IRQ_RETVAL(handled);
+}
+#endif
+
+/* Returns BAR register address */
+static int _pci_bar_reg_addr(int res)
+{
+ return 0x10 + res*4;
+}
+
+static void _pci_update_resource(struct pci_dev *dev, int resno)
+{
+ struct pci_bus_region region;
+ u16 cmd;
+ u32 new, check, mask;
+ int reg;
+ struct resource *res = dev->resource + resno;
+
+ /*
+ * Ignore resources for unimplemented BARs and unused resource slots
+ * for 64 bit BARs.
+ */
+ if (!res->flags)
+ return;
+
+ /*
+ * Ignore non-moveable resources. This might be legacy resources for
+ * which no functional BAR register exists or another important
+ * system resource we shouldn't move around.
+ */
+ if (res->flags & IORESOURCE_PCI_FIXED)
+ return;
+
+ pcibios_resource_to_bus(dev, ®ion, res);
+
+ new = region.start | (res->flags & PCI_REGION_FLAG_MASK);
+ if (res->flags & IORESOURCE_IO)
+ mask = (u32)PCI_BASE_ADDRESS_IO_MASK;
+ else
+ mask = (u32)PCI_BASE_ADDRESS_MEM_MASK;
+
+ reg = _pci_bar_reg_addr(resno);
+
+ pci_write_config_dword(dev, reg, new);
+ pci_read_config_dword(dev, reg, &check);
+
+ if ((new ^ check) & mask) {
+ dev_err(&dev->dev, "BAR %d: error updating (%#08x != %#08x)\n",
+ resno, new, check);
+ }
+
+ if (res->flags & IORESOURCE_MEM_64) {
+ new = region.start >> 16 >> 16;
+ pci_write_config_dword(dev, reg + 4, new);
+ pci_read_config_dword(dev, reg + 4, &check);
+ if (check != new) {
+ dev_err(&dev->dev, "BAR %d: error updating "
+ "(high %#08x != %#08x)\n", resno, new, check);
+ }
+ }
+
+ pci_read_config_word(dev, PCI_COMMAND, &cmd);
+ pci_write_config_word(dev, PCI_COMMAND, cmd | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
+
+ res->flags &= ~IORESOURCE_UNSET;
+ dev_info(&dev->dev, "BAR %d: set to %pR (PCI address [%#llx-%#llx])\n",
+ resno, res, (unsigned long long)region.start,
+ (unsigned long long)region.end);
+}
+
+/* Enable PCI access to device */
+bcmos_errno bcm_ll_pcie_dev_enable(int dev_id)
+{
+ maple_device_info *device;
+ int rc;
+
+ if (dev_id >= MAPLE_MAX_DEVICES)
+ return BCM_ERR_PARM;
+
+ device = &devices[dev_id];
+ if (!device->pdev)
+ return BCM_ERR_IO;
+
+ rc = pci_enable_device_mem(device->pdev);
+ if (rc)
+ {
+ printk("Error pci_enable_device_mem for device %d = %d\n", dev_id, rc);\
+ goto out;
+ }
+
+ /* Refresh devices's PCIe header */
+ _pci_update_resource(device->pdev, BAR_REGS);
+ _pci_update_resource(device->pdev, BAR_SRAM);
+ _pci_update_resource(device->pdev, BAR_DDR);
+ device->enabled = 1;
+
+out:
+ return rc ? BCM_ERR_IO : BCM_ERR_OK;
+}
+
+/* Disable PCI access to device */
+bcmos_errno bcm_ll_pcie_dev_disable(int dev_id)
+{
+ maple_device_info *device;
+
+ printk("%s: device %d\n", __FUNCTION__, dev_id);
+
+ if (dev_id >= MAPLE_MAX_DEVICES)
+ return BCM_ERR_PARM;
+
+ device = &devices[dev_id];
+ if (!device->pdev || !device->enabled)
+ return BCM_ERR_OK;
+ pci_disable_device(device->pdev);
+ device->enabled = 0;
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_ll_pcie_init(void)
+{
+ int rc;
+ if (is_initialized)
+ return BCM_ERR_OK;
+ is_initialized = BCMOS_TRUE;
+ rc = pci_register_driver(&maple_pci_driver);
+ printk(KERN_INFO "Maple PCI driver registered with PCI subsystem. rc=%d\n", rc);
+ return rc ? BCM_ERR_INTERNAL : BCM_ERR_OK;
+}
+
+void bcm_ll_pcie_cleanup(void)
+{
+ if (!is_initialized)
+ return;
+ is_initialized = BCMOS_FALSE;
+
+ pci_unregister_driver(&maple_pci_driver);
+ crt_device = 0;
+ memset(devices, 0, sizeof(devices));
+}
+
+/*******************************************/
+/* procedures executed on insmod and rmmod */
+/*******************************************/
+static int __init bcm_ll_init_module(void)
+{
+ struct proc_dir_entry *bcmolt_file = NULL;
+
+ if ((bcmolt_dir = create_proc_entry("bcmolt", S_IFDIR, NULL)) == NULL)
+ {
+ printk("Unable to create /proc/bcmolt entry\n");
+ return -1;
+ }
+ if ((bcmolt_file = create_proc_entry("card", S_IFREG | S_IWUSR | S_IRUGO, bcmolt_dir)) == NULL)
+ {
+ printk("Unable to create /proc/bcmolt/card entry\n");
+ remove_proc_entry("bcmolt", bcmolt_dir);
+ return -1;
+ }
+ bcmolt_file->write_proc = (write_proc_t *)maple_write;
+ bcmolt_file->read_proc = (read_proc_t *)maple_read;
+
+ return 0;
+}
+
+static void __exit bcm_ll_cleanup_module(void)
+{
+ bcm_ll_pcie_cleanup();
+ remove_proc_entry("card", bcmolt_dir);
+ remove_proc_entry("bcmolt", NULL);
+ printk("Unregister done\n");
+}
+
+/*****************************/
+/* APIs used by Host drivers */
+/*****************************/
+bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb)
+{
+ int i;
+ maple_device_info *device_info;
+
+ callback = cb;
+ if(callback)
+ {
+ for (i = 0; i < crt_device; i++)
+ {
+ device_info = get_maple_pci_info(i);
+ if (device_info)
+ callback(i, device_info->datalink);
+ else
+ callback(i, BCM_LL_PCIE_LINK_DOWN);
+ }
+ }
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_ll_pcie_status_change_unregister(void)
+{
+ callback = NULL;
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info)
+{
+ maple_device_info *device_info;
+
+ if (!info)
+ return BCM_ERR_PARM;
+
+ if (dev_id < MAPLE_MAX_DEVICES)
+ {
+ device_info = get_maple_pci_info(dev_id);
+ if (device_info && device_info->pdev)
+ {
+ if (device_info->datalink == BCM_LL_PCIE_LINK_DOWN)
+ return BCM_ERR_IO;
+ *info = device_info->device;
+ return BCM_ERR_OK;
+ }
+ return BCM_ERR_IO;
+ }
+ return BCM_ERR_RANGE;
+}
+
+bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id)
+{
+ maple_device_info *device_info;
+
+ if (dev_id < crt_device)
+ {
+ device_info = get_maple_pci_info(dev_id);
+ return (device_info ? device_info->pdev : NULL);
+ }
+
+ return NULL;
+}
+
+bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled)
+{
+ uint32_t val;
+
+ val = enabled ? 0 : 1;
+ bcm_pci_write32((uint32_t *)(devices[dev_id].device.soc_regs_base + PCIE_HARD_DEBUG_REGISTER_OFFSET), val);
+
+ return BCM_ERR_OK;
+}
+
+#ifdef TX_ENABLE_EVENT_TRACE
+bcmos_errno bcm_ll_pcie_setrace(uint8_t dev_id)
+{
+ maple_device_info *device_info;
+ uint32_t val,lim,base,size;
+ uint32_t reglo,reghi,baselim;
+ unsigned long addr;
+
+ if (dev_id < crt_device)
+ {
+ device_info = &devices[dev_id];
+ if (!device_info)
+ return BCM_ERR_IO;
+ size = EVENT_BUFFER_SIZE;
+ device_info->traceaddr = (unsigned int *)bcmos_alloc_not_cache(size);
+ memset(device_info->traceaddr,0,size);
+ addr = bcmos_virt_to_phys(device_info->traceaddr); /* | 0x02 = reverse byte order = swap */
+ printk("trace window : alloc=0x%lx size=0x%x\n",(unsigned long)device_info->traceaddr, (unsigned int)size);
+ reglo = PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_LO;
+ reghi = PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_HI;
+ baselim = PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_BASE_LIMIT;
+ bcm_pci_write32((uint32_t *)(device_info->device.soc_regs_base + reglo),addr & 0xffffffff);
+ bcm_pci_write32((uint32_t *)(device_info->device.soc_regs_base + reghi)),((addr >> 32) & 0xffffffff);
+ /* base */
+ base = CPU_2_PCIE_MEM_WIN1_BASE;
+ /* limit */
+ lim = base + size;
+ val = lim | (base >> 16);
+ bcm_pci_write32((uint32_t *)(device_info->device.soc_regs_base + baselim),val);
+ //bcm_fld_set_event_trace(dev_id);
+ bcm_pci_write32((uint32_t *)(device_info->device.soc_sram_base + BCM_FLD_EVENT_TRACE_OFFSET),0x1);
+
+ return BCM_ERR_OK;
+ }
+ return BCM_ERR_RANGE;
+}
+bcmos_errno bcm_ll_pcie_cleartrace(uint8_t dev_id)
+{
+ maple_device_info *device_info;
+
+ if (dev_id < crt_device)
+ {
+ device_info = &devices[dev_id];
+ if (!device_info)
+ return BCM_ERR_IO;
+ //bcm_fld_clear_event_trace(dev_id);
+ bcm_pci_write32((uint32_t *)(device_info->device.soc_sram_base + BCM_FLD_EVENT_TRACE_OFFSET),0x0);
+ return BCM_ERR_OK;
+ }
+ return BCM_ERR_RANGE;
+}
+bcmos_errno bcm_ll_pcie_savetrace(uint8_t dev_id, char *tracefilename)
+{
+ maple_device_info *device_info;
+ struct file *fp;
+ unsigned long seg = 0;
+ mm_segment_t memseg;
+
+ if (!tracefilename)
+ return BCM_ERR_PARM;
+
+ printk("device=%d from=%d, Go to write to file %s\n",dev_id , crt_device, tracefilename);
+
+ if (dev_id < crt_device)
+ {
+ device_info = &devices[dev_id];
+ if (!device_info)
+ {
+ printk("Error: device_info is null\n");
+ goto exit;
+ }
+ fp = filp_open(tracefilename, O_WRONLY | O_CREAT, 0666);
+ if ((fp == NULL) || (fp == (void *)-ENOENT))
+ {
+ printk("Error: Can't open file %s\n",tracefilename);
+ goto exit;
+ }
+ // Get current segment descriptor
+ seg = get_fs().seg;
+
+ // Set segment descriptor associated to kernel space
+ set_fs(get_ds());
+ fp->f_op->write(fp, (char *)device_info->traceaddr,EVENT_BUFFER_SIZE, &fp->f_pos);
+
+ memseg.seg = seg;
+ set_fs(memseg);
+ filp_close(fp, NULL);
+ printk("Wrote file %s\n",tracefilename);
+exit:
+ bcmos_free_not_cache(device_info->traceaddr);
+
+ return BCM_ERR_OK;
+ }
+ return BCM_ERR_RANGE;
+}
+#endif
+
+/*************************************************************/
+/* User interface functions : implement echo/cat to proc file*/
+/*************************************************************/
+
+typedef struct
+{
+ char *name;
+ void (*callback)(int cmdid, char *cmd);
+ char *description;
+} maple_card_command;
+
+static char *find_command(char *cmd);
+static void command_reg(int cmdid, char *line);
+static void command_mem(int cmdid, char *line);
+static void command_cfg(int cmdid, char *line);
+#ifdef TX_ENABLE_EVENT_TRACE
+static void command_trace(int cmdid, char *line);
+#endif
+
+#define READCMD 0
+#define WRITECMD 1
+
+static maple_card_command commands[] =
+{
+ {"readreg", command_reg, "read register <index> <register offset - hex>"},
+ {"writereg", command_reg, "write register <index> <register offset - hex> <value - hex>"},
+ {"read", command_mem, "read <address - hex> <number of words - dec>"},
+ {"write", command_mem, "write <address - hex> <value - hex>"},
+ {"rcfg", command_cfg, "read dev <address - hex> <number of words - dec>"},
+ {"wcfg", command_cfg, "write dev <address - hex> <value - hex>"},
+#ifdef TX_ENABLE_EVENT_TRACE
+ {"trace", command_trace, "trace <index> on/off/save tx trace"},
+#endif
+ {NULL, NULL, NULL}
+};
+
+static char *find_command(char *cmd)
+{
+ char *rest;
+ int i = 0;
+ maple_card_command *cmdptr = &commands[0];
+
+ cmd = skip_spaces(cmd);
+ if (!strncmp(cmd,"help",strlen("help")))
+ {
+ while (cmdptr->name)
+ {
+ printk("%s\t: %s\n",cmdptr->name, cmdptr->description);
+ cmdptr = &commands[++i];
+ }
+ return NULL;
+ }
+ while (cmdptr->name)
+ {
+ if (!strncmp(cmdptr->name, cmd, strlen(cmdptr->name)))
+ {
+ rest = cmd + strlen(cmdptr->name);
+ rest = skip_spaces(rest);
+ cmdptr->callback(i%2, rest);
+ return NULL;
+ }
+ cmdptr = &commands[++i];
+ }
+
+ return "Wrong command name";
+}
+/**********************************************************************
+ answers to cat /proc/bcmolt command
+**********************************************************************/
+static int maple_read(char *page, char **start, off_t off, int count, int *eof, void *data)
+{
+ int i;
+ int len;
+ maple_device_info *dev = NULL;
+
+ len = sprintf(page, "Maple Device Info\n\n");
+ for (i = 0; i < MAPLE_MAX_DEVICES; i++)
+ {
+ dev = get_maple_pci_info(i);
+ if (dev)
+ {
+ len += sprintf(page + len, "id=%d regs_start=0x%lx ddr_start=0x%lx sram_start=0x%lx ddr_length=%d\n",
+ dev->deviceid,
+ dev->device.soc_regs_base,dev->device.soc_ddr_base,
+ dev->device.soc_sram_base, (int)dev->device.soc_ddr_length);
+ len += sprintf(page + len, "Phy Link is %s Data Link is %s Error status = %d\n\n",
+ dev->phylink == 1 ? "UP" : "DOWN", dev->datalink == 1 ? "UP" : "DOWN", (int)dev->err_status);
+ }
+ }
+
+ return len;
+}
+#ifdef TX_ENABLE_EVENT_TRACE
+static void command_trace(int cmdid, char *line)
+{
+ char token[5];
+ int index;
+
+ if (sscanf(line, "%d %s", &index, token) != 2)
+ {
+ printk("Wrong parameter\n");
+ return;
+ }
+ printk("TRACE commands : %s\n",token);
+ if (!strncmp(token,"on",2))
+ {
+ //on
+ bcm_ll_pcie_setrace(index);
+ return;
+ }
+ if (!strncmp(token,"off",3))
+ {
+ // off
+ bcm_ll_pcie_cleartrace(index);
+ return;
+ }
+ if (!strncmp(token,"save",4))
+ {
+ //get
+ char filename[20];
+ sprintf(filename,"./tt_trace_%d.trx",index);
+ bcm_ll_pcie_savetrace(index,filename);
+ return;
+ }
+ printk("Wrong command\n");
+}
+#endif
+
+
+static void command_reg(int cmdindex, char *line)
+{
+ char *rest;
+ char *token;
+ int index;
+ unsigned long address;
+ unsigned int reg;
+
+ if (sscanf(line, "%d %lx", &index, &address) != 2)
+ {
+ printk("Wrong parameter\n");
+ return;
+ }
+ address += (unsigned long)devices[index].device.soc_regs_base;
+ switch (cmdindex)
+ {
+ case READCMD:
+ reg = bcm_pci_read32((uint32_t *)address);
+ printk("0x%lx : %08x\n", address, reg);
+ break;
+ case WRITECMD:
+ rest = line;
+ token = strsep(&rest, " "); /* skip index */
+ token = strsep(&rest, " "); /* skip address */
+ token = strsep(&rest, " ");
+ if (!token)
+ {
+ printk("Wrong parameter\n");
+ return;
+ }
+ sscanf(token, "%x", ®);
+ printk("write 0x%x to 0x%lx\n", reg, address);
+ bcm_pci_write32((uint32_t *)address,reg);
+ break;
+ }
+}
+
+static void command_mem(int cmdindex, char *line)
+{
+ char *token;
+ char *rest;
+ unsigned long address;
+ unsigned int reg;
+ int i, number_of_words;
+ int in_line=0, max_in_line;
+
+ if (sscanf(line, "%lx", &address) != 1)
+ {
+ printk("Wrong parameter\n");
+ return;
+ }
+ rest = line;
+ token = strsep(&rest, " "); /* skip address */
+ switch (cmdindex)
+ {
+ case READCMD:
+ token = strsep(&rest, " ");
+ if (!token)
+ number_of_words = 1;
+ else
+ sscanf(token, "%d", &number_of_words);
+
+ max_in_line = 4;
+ for (i = 0; i < number_of_words; i++, address += 4)
+ {
+ if (!in_line)
+ printk("%08lx: ", address);
+ reg = bcm_pci_read32((uint32_t *)address);
+ printk("%08x", reg);
+ if (++in_line < max_in_line)
+ printk(" ");
+ else
+ {
+ printk("\n");
+ in_line = 0;
+ }
+ }
+ if (in_line)
+ printk("\n");
+ break;
+ case WRITECMD:
+ token = strsep(&rest, " ");
+ if (!token)
+ {
+ printk("Wrong parameter\n");
+ return;
+ }
+ sscanf(token, "%x", ®);
+ bcm_pci_write32((uint32_t *)address,reg);
+ break;
+ }
+}
+
+static void command_cfg(int cmdindex, char *line)
+{
+ unsigned long address;
+ unsigned int reg;
+ unsigned int val_or_num;
+ int crt;
+ int i;
+ int in_line=0, max_in_line;
+ maple_device_info *device;
+
+ if (sscanf(line, "%d %lx %x", &crt, &address, &val_or_num) != 3)
+ {
+ printk("Wrong parameter\n");
+ return;
+ }
+
+ if (crt >= crt_device || !devices[crt].pdev)
+ {
+ printk("Invalid device %d\n", crt);
+ return;
+ }
+
+ device = &devices[crt];
+
+ switch (cmdindex)
+ {
+ case READCMD:
+ max_in_line = 4;
+ for (i = 0; i < val_or_num; i++, address += 4)
+ {
+ if (!in_line)
+ printk("%08lx: ", address);
+ pci_read_config_dword(device->pdev, address, ®);
+ printk("%08x", reg);
+ if (++in_line < max_in_line)
+ printk(" ");
+ else
+ {
+ printk("\n");
+ in_line = 0;
+ }
+ }
+ if (in_line)
+ printk("\n");
+ break;
+
+ case WRITECMD:
+ pci_write_config_dword(device->pdev, address, val_or_num);
+ break;
+ }
+}
+
+/**********************************************************************
+ answers to echo [...] > /proc/bcmolt command
+**********************************************************************/
+static int maple_write(struct file *file,const char *buffer,size_t count, void *data)
+{
+ char *internal;
+
+ if (buffer == NULL)
+ return -EFAULT;
+
+ internal = kmalloc(count, GFP_KERNEL);
+ if (!internal)
+ {
+ printk("Not enough memmory\n");
+ return count;
+ }
+
+ memset(internal, 0, count);
+ if (copy_from_user(internal, buffer, count))
+ {
+ printk("Not enough memmory\n");
+ goto error;
+ }
+ find_command(internal);
+
+error:
+ kfree(internal);
+
+ return count;
+}
+
+EXPORT_SYMBOL(bcmolt_dir);
+EXPORT_SYMBOL(bcm_ll_pcie_init);
+EXPORT_SYMBOL(bcm_ll_pcie_cleanup);
+EXPORT_SYMBOL(bcm_ll_pcie_status_change_register);
+EXPORT_SYMBOL(bcm_ll_pcie_status_change_unregister);
+EXPORT_SYMBOL(bcm_ll_pcie_query);
+EXPORT_SYMBOL(bcm_ll_pcie_dev_get);
+EXPORT_SYMBOL(bcm_ll_pcie_dev_enable);
+EXPORT_SYMBOL(bcm_ll_pcie_dev_disable);
+EXPORT_SYMBOL(bcm_ll_pcie_host_reset_enable);
+
+#ifdef TX_ENABLE_EVENT_TRACE
+EXPORT_SYMBOL(bcm_ll_pcie_setrace);
+EXPORT_SYMBOL(bcm_ll_pcie_cleartrace);
+EXPORT_SYMBOL(bcm_ll_pcie_savetrace);
+#endif
+module_init(bcm_ll_init_module);
+module_exit(bcm_ll_cleanup_module);
+
+MODULE_DESCRIPTION("maple line card");
+MODULE_LICENSE("Dual BSD/GPL");
diff --git a/bcm68620_release/release/host_customized/ll_pcie/bcmolt_llpcie.h b/bcm68620_release/release/host_customized/ll_pcie/bcmolt_llpcie.h
new file mode 100755
index 0000000..bd1a60e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/bcmolt_llpcie.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.
+
+:>
+ */
+
+/*
+ * bcm_llpcie.h - Low-level PCIe driver interface
+ */
+
+#ifndef BCMOLT_LLPCIE_H_
+#define BCMOLT_LLPCIE_H_
+
+#include "bcmos_system.h"
+#define MAPLE_MAX_DEVICES BCMTR_MAX_OLTS
+
+/** Low-level device info */
+typedef struct bcmolt_ll_dev_info
+{
+ unsigned long soc_regs_base; /**< Device registers base in host address space */
+ unsigned long soc_sram_base; /**< Device SRAM base in host address space */
+ unsigned long soc_ddr_base; /**< Device DDR base in host address space */
+ uint32_t soc_ddr_length; /**< Device DDR window size */
+ uint32_t irq; /**< Device irq number */
+ int irq_connected; /**< Device irq number connected */
+} bcm_ll_dev_info;
+
+/** Device PCIe link status change notification callback */
+typedef enum
+{
+ BCM_LL_PCIE_LINK_DOWN, /**< PCIe link is down */
+ BCM_LL_PCIE_LINK_UP, /**< PCIe link is up */
+} bcm_ll_pcie_link_status;
+
+/** Low-level device handle */
+typedef void *bcm_ll_pcie_dev;
+
+/** Status change indication */
+typedef void (*bcm_ll_pcie_status_change)(uint8_t dev_id, bcm_ll_pcie_link_status status);
+
+/** Register status change notification callback
+ * \param[in] cb Status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb);
+
+/** Unregister status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_unregister(void);
+
+/** Query PCIe device
+ * \param[in] dev_id Device id
+ * \param[out] info Device info
+ * \return 0=OK, BCM_ERR_IO-dev_id is in proper range, but link is down
+ */
+bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info);
+
+/** Get low-level device handle
+ * \param[in] dev_id Device id
+ * \param[out] lldev Low-level device handle
+ * \return device handle or NULL if link is down
+ */
+bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id);
+
+/* Initialize low-level PCIe driver
+ * \return
+ * - 0=OK
+ * - BCM_ERR_INTERNAL - failed to register with PCI subsystem
+ */
+bcmos_errno bcm_ll_pcie_init(void);
+
+/* Cleanup low-level PCIe driver */
+void bcm_ll_pcie_cleanup(void);
+
+/** Enable PCI access to device
+ * \param[in] dev_id Device id
+ * \return
+ * - 0=OK
+ * - BCM_ERR_PARM-dev_id is invalid
+ * - BCM_ERR_IO-dev_id is in proper range, but link is down
+ */
+bcmos_errno bcm_ll_pcie_dev_enable(int dev_id);
+
+/** Disable PCI access to device
+ * \param[in] dev_id Device id
+ * \return
+ * - 0=OK
+ * - BCM_ERR_PARM-dev_id is invalid
+ */
+bcmos_errno bcm_ll_pcie_dev_disable(int dev_id);
+
+/** Enable/disable host reset for all PCIe interfaces (automatic
+ * device reset when host is reset)
+ * \param[in] enabled Whether or not hot reset should be enabled
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled);
+
+#ifdef TX_ENABLE_EVENT_TRACE
+/** Handle low-level trace on target
+ * \param[in] dev_id Device id
+ * \param[in] lfile name for trace
+ * \return device handle or NULL if link is down
+ */
+bcmos_errno bcm_ll_pcie_setrace(uint8_t dev_id);
+bcmos_errno bcm_ll_pcie_cleartrace(uint8_t dev_id);
+bcmos_errno bcm_ll_pcie_savetrace(uint8_t dev_id, char *tracefilename);
+#endif
+
+#endif
diff --git a/bcm68620_release/release/host_customized/ll_pcie/vxworks/bcmolt_llpcie.c b/bcm68620_release/release/host_customized/ll_pcie/vxworks/bcmolt_llpcie.c
new file mode 100644
index 0000000..df6d3c0
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/vxworks/bcmolt_llpcie.c
@@ -0,0 +1,410 @@
+/*
+<: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 <vxWorks.h>
+#include <drv/pci/pciConfigLib.h>
+#include "bcmolt_llpcie.h"
+
+/* Define PCIE device BAR registers */
+#define BAR_REGS 0
+#define BAR_DDR 2
+#define BAR_SRAM 4
+
+/*
+Define PCIE device BAR space length:
+ bar 1 = 8 Mbyte register space
+ bar 2 = 16 Mbyte DDR space
+ bar 3 = 64 Kbyte SRAM space
+*/
+#define MAPLE_REGS_LENGTH 0x00800000
+#define MAPLE_DDR_LENGTH 0x01000000
+#define MAPLE_SRAM_LENGTH 0x00010000
+
+/* Define special registers address */
+#ifdef TX_ENABLE_EVENT_TRACE
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_LO 0x064014U
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_HI 0x064018U
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_BASE_LIMIT 0x064074U
+#endif
+#define PCIE_REVISION_REGISTER_OFFSET 0x6406C /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_REVISION */
+#define PCIE_STATUS_REGISTER_OFFSET 0x64068 /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_PCIE_STATUS */
+#define PCIE_HARD_DEBUG_REGISTER_OFFSET 0x64204U /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_HARD_DEBUG */
+#define PCIE_INT_STATUS_REGISTER_OFFSET 0x69400 /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_STATUS */
+#define PCIE_INT_CLEAR_MASK_OFFSET 0x6940C /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_MASK_CLEAR */
+#define PCIE_INTR1_STATUS_REGISTER_OFFSET 0x69300 /* Interrupt Status Register */
+
+/* Maple device ID */
+#define PCIE_MAPLE_VENDOR_ID 0x14E4 /* PCIE_CFG_TYPE0_EP_SUBSYSTEM_ID_VENDOR_ID */
+#define PCIE_MAPLE_DEVICE_ID 0x6862
+#define PCIE_MAPLE_6863_SKU_DEVICE_ID 0x6863
+#define PCIE_MAPLE_EPON_DEVICE_ID 0x5554
+
+/* Define interrupt vector number according BCM53003 BSP */
+#define PCIE1_IV_0 86
+#define PCIE1_IV_1 87
+#define PCIE1_INT_LINE 4
+
+/* Maple device object struct */
+typedef struct
+{
+ bcm_ll_dev_info device;
+ bcmos_fastlock lock;
+ int err_status;
+ int phylink;
+ int prev_datalink;
+ int datalink;
+ uint32_t deviceid; // start from 0
+ unsigned int *traceaddr;
+ void *pdev;
+ int pciBusNo; /* PCI bus number */
+ int pciDevNo; /* PCI device number */
+ int pciFuncNo; /* PCI function number */
+ uint32_t dev_status_irq;
+} maple_device_info;
+
+/* Maple device objects */
+static maple_device_info devices[MAPLE_MAX_DEVICES];
+int crt_device = 0;
+
+/* Device PCIE interface status change callback */
+static bcm_ll_pcie_status_change callback;
+
+/** Device status change ISR
+ * \irq IRQ number
+ * \dev_instance device object
+ */
+int dev_status_interrupt (int irq, void *dev_instance)
+{
+ bcmos_errno err = BCM_ERR_OK;
+ uint32_t reg_value = 0;
+ maple_device_info *device_info = NULL;
+ long flags = 0;
+ int handled = 0;
+ uint32_t dev_id = 0;
+
+ device_info = (maple_device_info *)dev_instance;
+ dev_id = device_info->deviceid;
+
+ flags = bcmos_fastlock_lock(&device_info->lock);
+
+ reg_value = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_INT_STATUS_REGISTER_OFFSET));
+ {
+ if (device_info->datalink != device_info->prev_datalink)
+ {
+ if (device_info->datalink == BCM_LL_PCIE_LINK_UP)
+ printf("Device=%d : Link is up !!!\n", dev_id);
+ else
+ {
+ printf("Device=%d : Link is down !!!\n", dev_id);
+ printf("phy status = 0x%x error status = 0x%x\n", device_info->phylink, device_info->err_status);
+ }
+ device_info->prev_datalink = device_info->datalink;
+ if (callback)
+ {
+ callback(dev_id, device_info->datalink);
+ }
+ }
+ reg_value = bcm_pci_read32(
+ (uint32_t *)(device_info->device.soc_regs_base + PCIE_INTR1_STATUS_REGISTER_OFFSET));
+ {
+ handled = 1;
+ }
+ }
+
+ bcmos_fastlock_unlock(&device_info->lock, flags);
+
+ return handled;
+}
+
+/** Maple device detection and initialization
+ */
+bcmos_errno bcm_ll_pcie_interface_init()
+{
+ STATUS ret_status;
+ maple_device_info *dev_info = NULL;
+ uint32_t readval = 0;
+ uint8_t readvalb = 0;
+ bcmos_errno err = BCM_ERR_OK;
+ uint8_t irq = 0;
+ uint16_t device_id;
+
+ printf("%s()\r\n", __FUNCTION__);
+
+ // check maple device number
+ if (crt_device == MAPLE_MAX_DEVICES)
+ {
+ printf(" Maximum Maple devices already defined (%d)\n", MAPLE_MAX_DEVICES);
+ return BCM_ERR_ALREADY;
+ }
+ // Init device object struct
+ dev_info = &devices[crt_device++];
+ memset(dev_info, 0, sizeof(maple_device_info));
+
+ // find maple 6862 device
+ ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID,
+ PCIE_MAPLE_DEVICE_ID,
+ 0,
+ &dev_info->pciBusNo,
+ &dev_info->pciDevNo,
+ &dev_info->pciFuncNo);
+
+ if (OK == ret_status)
+ {
+ device_id = PCIE_MAPLE_DEVICE_ID;
+ goto found_device_id;
+ }
+
+ // find maple 6863 device
+ ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID,
+ PCIE_MAPLE_6863_SKU_DEVICE_ID,
+ 0,
+ &dev_info->pciBusNo,
+ &dev_info->pciDevNo,
+ &dev_info->pciFuncNo);
+
+ if (OK == ret_status)
+ {
+ device_id = PCIE_MAPLE_6863_SKU_DEVICE_ID;
+ goto found_device_id;
+ }
+
+ // find maple epon device
+ ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID,
+ PCIE_MAPLE_EPON_DEVICE_ID,
+ 0,
+ &dev_info->pciBusNo,
+ &dev_info->pciDevNo,
+ &dev_info->pciFuncNo);
+
+ if (OK == ret_status)
+ {
+ device_id = PCIE_MAPLE_EPON_DEVICE_ID;
+ goto found_device_id;
+ }
+
+ printf("Can't find any device[%d]\n", PCIE_MAPLE_VENDOR_ID);
+ return BCM_ERR_NODEV;
+
+found_device_id:
+ printf("Found maple device[%x - %x]\n", PCIE_MAPLE_VENDOR_ID, device_id);
+
+ // init
+ dev_info->deviceid = (crt_device - 1);
+ dev_info->pdev = NULL;
+
+
+ // Enable PCI address map
+ pciConfigInByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_COMMAND,
+ (UINT8 *)&readvalb);
+ printf("CMD reg = 0x%x\n", readvalb);
+
+ readvalb |= 0x6;
+ pciConfigOutByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_COMMAND,
+ (UINT8)readvalb);
+
+ pciConfigInByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_COMMAND,
+ (UINT8 *)&readvalb);
+ printf("Adjusted CMD reg = 0x%x\n", readvalb);
+
+ // Init base addresses
+ dev_info->device.soc_regs_base = 0xe0000000;
+ dev_info->device.soc_sram_base = 0xe2000000;
+ dev_info->device.soc_ddr_base = 0xe1000000;
+ dev_info->device.soc_ddr_length = 0x1000000; // 16M
+
+ // init interrupt line
+ readvalb = PCIE1_INT_LINE;
+ pciConfigOutByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_DEV_INT_LINE,
+ (UINT8)readvalb);
+ pciConfigInByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_DEV_INT_LINE,
+ (UINT8 *)&readvalb);
+ printf("Adjusted INT Line reg = 0x%x\n", readvalb);
+
+ // init interrupt
+ dev_info->device.irq = PCIE1_IV_0;
+ dev_info->dev_status_irq = PCIE1_IV_1;
+
+ // read revision register
+ readval = bcm_pci_read32((uint32_t *)(dev_info->device.soc_regs_base + PCIE_REVISION_REGISTER_OFFSET));
+ printf("readval = 0x%x\n", readval);
+ printf("Card %d version major=%02x minor=%02x\n",
+ dev_info->deviceid,
+ ((readval & 0x0000ff00) >> 8),
+ (readval & 0x000000ff));
+
+ // read status register
+ readval = bcm_pci_read32((uint32_t *)(dev_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET));
+ printf("readval = 0x%x\n", readval);
+ dev_info->err_status = (readval & 0x0000000f);
+ dev_info->phylink = ((readval >> 4) & 0x1);
+ dev_info->datalink = ((readval >> 5) & 0x1);
+ dev_info->prev_datalink = dev_info->datalink;
+
+ // connect INT for device status
+ bcmos_fastlock_init(&dev_info->lock, 0);
+ bcmos_int_connect((int)dev_info->dev_status_irq,
+ 0,
+ BCMOS_IRQ_SHARED,
+ dev_status_interrupt,
+ "status_isr",
+ dev_info);
+
+ return BCM_ERR_OK;
+}
+
+/** Get Maple device object struct
+ * \crt devie index,start from 0
+ */
+static maple_device_info *get_maple_pci_info(int crt)
+{
+ bcmos_errno err = BCM_ERR_OK;
+ uint32_t readval = 0;
+ maple_device_info *device_info = NULL;
+
+ /* check input parameter */
+ if (MAPLE_MAX_DEVICES <= crt)
+ {
+ return NULL;
+ }
+ device_info = &devices[crt];
+
+ /* read status register */
+ readval = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET));
+ device_info->err_status = (readval & 0x0000000f);
+ device_info->phylink = ((readval >> 4) & 0x1);
+ device_info->datalink = ((readval >> 5) & 0x1);
+
+ /* return device */
+ return device_info;
+}
+
+/** Register status change notification callback
+ * \param[in] cb Status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb)
+{
+ int i;
+ maple_device_info *dev_info;
+
+ callback = cb;
+ for (i = 0; i < crt_device; i++)
+ {
+ dev_info = get_maple_pci_info(i);
+ callback(i, dev_info->datalink);
+ }
+
+ return BCM_ERR_OK;
+}
+
+/** Unregister status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_unregister(void)
+{
+ callback = NULL;
+
+ return BCM_ERR_OK;
+}
+
+/** Query PCIe device
+ * \param[in] dev_id Device id
+ * \param[out] info Device info
+ * \return 0=OK, BCM_ERR_IO-dev_id is in proper range, but link is down
+ */
+bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info)
+{
+ maple_device_info *dev_info;
+
+ if (NULL == info)
+ {
+ return BCM_ERR_PARM;
+ }
+
+ if (dev_id < crt_device)
+ {
+ dev_info = get_maple_pci_info(dev_id);
+ if (dev_info->datalink == BCM_LL_PCIE_LINK_DOWN)
+ {
+ return BCM_ERR_IO;
+ }
+
+ *info = dev_info->device;
+ return BCM_ERR_OK;
+ }
+
+ return BCM_ERR_RANGE;
+}
+
+/** Get low-level device handle
+ * \param[in] dev_id Device id
+ * \param[out] lldev Low-level device handle
+ * \return device handle or NULL if link is down
+ */
+bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id)
+{
+ maple_device_info *dev_info;
+
+ if (dev_id < MAPLE_MAX_DEVICES)
+ {
+ dev_info = get_maple_pci_info(dev_id);
+ return dev_info->pdev;
+ }
+
+ return NULL;
+}
+
+/** Host reset enable
+ * \enabled
+ */
+bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled)
+{
+ uint32_t val;
+
+ val = enabled ? 0 : 1;
+ bcm_pci_write32((uint32_t *)(devices[dev_id].device.soc_regs_base + PCIE_HARD_DEBUG_REGISTER_OFFSET) , val);
+
+ return BCM_ERR_OK;
+}
+
diff --git a/bcm68620_release/release/host_customized/ll_pcie/vxworks/bcmolt_llpcie.h b/bcm68620_release/release/host_customized/ll_pcie/vxworks/bcmolt_llpcie.h
new file mode 100644
index 0000000..d484976
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/vxworks/bcmolt_llpcie.h
@@ -0,0 +1,105 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcm_llpcie.h - Low-level PCIe driver interface
+ */
+
+#ifndef BCMOLT_LLPCIE_H_
+#define BCMOLT_LLPCIE_H_
+
+#include "bcmos_system.h"
+#define MAPLE_MAX_DEVICES 1 /* 5 */
+
+/** Low-level device info */
+typedef struct bcmolt_ll_dev_info
+{
+ unsigned long soc_regs_base; /**< Device registers base in host address space */
+ unsigned long soc_sram_base; /**< Device SRAM base in host address space */
+ unsigned long soc_ddr_base; /**< Device DDR base in host address space */
+ uint32_t soc_ddr_length; /**< Device DDR window size */
+ uint32_t irq; /**< Device irq number */
+} bcm_ll_dev_info;
+
+/** Device PCIe link status change notification callback */
+typedef enum
+{
+ BCM_LL_PCIE_LINK_DOWN, /**< PCIe link is down */
+ BCM_LL_PCIE_LINK_UP, /**< PCIe link is up */
+} bcm_ll_pcie_link_status;
+
+/** Low-level device handle */
+typedef void *bcm_ll_pcie_dev;
+
+/** Status change indication */
+typedef void (*bcm_ll_pcie_status_change)(uint8_t dev_id, bcm_ll_pcie_link_status status);
+
+/** Register status change notification callback
+ * \param[in] cb Status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb);
+
+/** Unregister status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_unregister(void);
+
+/** Query PCIe device
+ * \param[in] dev_id Device id
+ * \param[out] info Device info
+ * \return 0=OK, BCM_ERR_IO-dev_id is in proper range, but link is down
+ */
+bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info);
+
+/** Get low-level device handle
+ * \param[in] dev_id Device id
+ * \param[out] lldev Low-level device handle
+ * \return device handle or NULL if link is down
+ */
+bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id);
+
+/** Enable/disable host reset for all PCIe interfaces (automatic
+ * device reset when host is reset)
+ * \param[in] enabled Whether or not hot reset should be enabled
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled);
+
+#ifdef TX_ENABLE_EVENT_TRACE
+/** Handle low-level trace on target
+ * \param[in] dev_id Device id
+ * \param[in] lfile name for trace
+ * \return device handle or NULL if link is down
+ */
+bcmos_errno bcm_ll_pcie_setrace(uint8_t dev_id);
+bcmos_errno bcm_ll_pcie_cleartrace(uint8_t dev_id);
+bcmos_errno bcm_ll_pcie_savetrace(uint8_t dev_id, char *tracefilename);
+#endif
+#endif
diff --git a/bcm68620_release/release/host_customized/ll_pcie/vxworks/multi_device/bcmolt_llpcie.c b/bcm68620_release/release/host_customized/ll_pcie/vxworks/multi_device/bcmolt_llpcie.c
new file mode 100755
index 0000000..1de7475
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/vxworks/multi_device/bcmolt_llpcie.c
@@ -0,0 +1,505 @@
+/*
+<: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 <vxWorks.h>
+#include <drv/pci/pciConfigLib.h>
+#include "bcmolt_llpcie.h"
+
+/* Define PCIE device BAR registers */
+#define BAR_REGS 0
+#define BAR_DDR 2
+#define BAR_SRAM 4
+
+/*
+Define PCIE device BAR space length:
+ bar 0 = 8 Mbyte register space
+ bar 2 = 16 Mbyte DDR space
+ bar 4 = 64 Kbyte SRAM space
+*/
+#define MAPLE_REGS_LENGTH 0x00800000
+#define MAPLE_DDR_LENGTH 0x01000000
+#define MAPLE_SRAM_LENGTH 0x00010000
+
+/* Define special registers address */
+#ifdef TX_ENABLE_EVENT_TRACE
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_LO 0x064014U
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_HI 0x064018U
+#define PCIE_PCIE_0_MISC_CPU_2_PCIE_MEM_WIN1_BASE_LIMIT 0x064074U
+#endif
+#define PCIE_REVISION_REGISTER_OFFSET 0x6406C /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_REVISION */
+#define PCIE_STATUS_REGISTER_OFFSET 0x64068 /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_PCIE_STATUS */
+#define PCIE_HARD_DEBUG_REGISTER_OFFSET 0x64204U /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_HARD_DEBUG */
+#define PCIE_INT_STATUS_REGISTER_OFFSET 0x69400 /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_STATUS */
+#define PCIE_INT_CLEAR_MASK_OFFSET 0x6940C /* PCIE_PCIE_PCIE_0_CPU_INTR1_INTR_MASK_CLEAR */
+#define PCIE_INTR1_STATUS_REGISTER_OFFSET 0x69300 /* Interrupt Status Register */
+
+/* Maple device ID */
+#define PCIE_MAPLE_VENDOR_ID 0x14E4 /* PCIE_CFG_TYPE0_EP_SUBSYSTEM_ID_VENDOR_ID */
+#define PCIE_MAPLE_DEVICE_ID 0x6862
+#define PCIE_MAPLE_6863_SKU_DEVICE_ID 0x6863
+#define PCIE_MAPLE_EPON_DEVICE_ID 0x5554
+
+/* Define interrupt vector number for MPC8308 */
+#define DRV_PCIE_INT_IRQ_BASE 96
+#define PCIE_DEV0_IV_0 (DRV_PCIE_INT_IRQ_BASE + 24)
+#define PCIE_DEV0_IV_1 (DRV_PCIE_INT_IRQ_BASE + 25)
+#define PCIE_DEV1_IV_0 (DRV_PCIE_INT_IRQ_BASE + 0)
+#define PCIE_DEV1_IV_1 (DRV_PCIE_INT_IRQ_BASE + 1)
+
+/* Maple device object struct */
+typedef struct
+{
+ uint32_t llpcie_irq;
+ uint32_t llpcie_status_irq;
+} maple_llpcie_device_irqs;
+
+maple_llpcie_device_irqs llpcie_device_irqs[BCMOLT_MAX_MAPLE_DEVICES] =
+{
+ {PCIE_DEV0_IV_0,PCIE_DEV0_IV_1},
+ {PCIE_DEV1_IV_0,PCIE_DEV1_IV_1}
+};
+
+
+#ifdef LLPCIE_SET_BASE_ADDRESSES_MANUALLY
+
+typedef struct
+{
+ unsigned long soc_regs_base; /**< Device registers base in host address space */
+ unsigned long soc_sram_base; /**< Device SRAM base in host address space */
+ unsigned long soc_ddr_base; /**< Device DDR base in host address space */
+
+} maple_llpcie_base_addresses;
+
+maple_llpcie_base_addresses llpcie_base_addresses[BCMOLT_MAX_MAPLE_DEVICES] =
+{
+ {.soc_regs_base = 0xe0000000, .soc_sram_base = 0xe2000000, .soc_ddr_base = 0xe1000000},
+ /* in this example there is only one device*/
+ {.soc_regs_base = 0x00000000, .soc_sram_base = 0x00000000, .soc_ddr_base = 0x00000000}
+};
+#endif
+
+/* Maple device object struct */
+typedef struct
+{
+ bcm_ll_dev_info device;
+ bcmos_fastlock lock;
+ int err_status;
+ int phylink;
+ int prev_datalink;
+ int datalink;
+ uint32_t deviceid; // start from 0
+ unsigned int *traceaddr;
+ void *pdev;
+ int pciBusNo; /* PCI bus number */
+ int pciDevNo; /* PCI device number */
+ int pciFuncNo; /* PCI function number */
+ uint32_t dev_status_irq;
+} maple_device_info;
+
+/* Maple device objects */
+maple_device_info g_maple_devs_info[BCMOLT_MAX_MAPLE_DEVICES];
+
+int g_maple_dev_num = 0;
+
+/* Device PCIE interface status change callback */
+bcm_ll_pcie_status_change g_dev_status_change_cb;
+
+/** Device status change ISR
+ * \irq IRQ number
+ * \dev_instance device object
+ */
+int dev_status_interrupt (int irq, void *dev_instance)
+{
+ uint32_t reg_value = 0;
+ maple_device_info *device_info = NULL;
+ long flags = 0;
+ int handled = 0;
+ uint32_t dev_id = 0;
+
+ device_info = (maple_device_info *)dev_instance;
+ dev_id = device_info->deviceid;
+
+ flags = bcmos_fastlock_lock(&device_info->lock);
+
+ reg_value = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_INT_STATUS_REGISTER_OFFSET));
+ {
+ if (device_info->datalink != device_info->prev_datalink)
+ {
+ if (device_info->datalink == BCM_LL_PCIE_LINK_UP)
+ printf("Device=%d : Link is up !!!\n", dev_id);
+ else
+ {
+ printf("Device=%d : Link is down !!!\n", dev_id);
+ printf("phy status = 0x%x error status = 0x%x\n", device_info->phylink, device_info->err_status);
+ }
+ device_info->prev_datalink = device_info->datalink;
+ if (g_dev_status_change_cb)
+ {
+ g_dev_status_change_cb(dev_id, device_info->datalink);
+ }
+ }
+ reg_value = bcm_pci_read32(
+ (uint32_t *)(device_info->device.soc_regs_base + PCIE_INTR1_STATUS_REGISTER_OFFSET));
+ {
+ handled = 1;
+ }
+ }
+
+ bcmos_fastlock_unlock(&device_info->lock, flags);
+
+ return handled;
+}
+
+/** Maple device detection and initialization
+ */
+bcmos_errno bcm_ll_pcie_interface_init()
+{
+ STATUS ret_status;
+ maple_device_info *dev_info = NULL;
+ uint32_t readval = 0;
+ uint8_t readvalb = 0;
+ uint32_t pci_dev_idx = 0;
+
+ printf("%s()\r\n", __FUNCTION__);
+
+ // check maple device number
+ if (g_maple_dev_num >= BCMOLT_MAX_MAPLE_DEVICES)
+ {
+ printf("Maximum Maple devices already defined (%d)\n", BCMOLT_MAX_MAPLE_DEVICES);
+ return BCM_ERR_ALREADY;
+ }
+
+ // Support multiple Maple devices
+ for (pci_dev_idx = 0; pci_dev_idx < BCMOLT_MAX_MAPLE_DEVICES; pci_dev_idx++)
+ {
+ uint16_t device_id;
+
+ // Init device object struct
+ dev_info = &g_maple_devs_info[pci_dev_idx];
+ memset(dev_info, 0, sizeof(maple_device_info));
+
+ // Try to find maple device
+ ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID,
+ PCIE_MAPLE_DEVICE_ID,
+ pci_dev_idx,
+ &dev_info->pciBusNo,
+ &dev_info->pciDevNo,
+ &dev_info->pciFuncNo);
+
+ if (ret_status == OK)
+ {
+ device_id = PCIE_MAPLE_DEVICE_ID;
+ goto found_device_id;
+ }
+
+ ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID,
+ PCIE_MAPLE_6863_SKU_DEVICE_ID,
+ pci_dev_idx,
+ &dev_info->pciBusNo,
+ &dev_info->pciDevNo,
+ &dev_info->pciFuncNo);
+
+ if (ret_status == OK)
+ {
+ device_id = PCIE_MAPLE_6863_SKU_DEVICE_ID;
+ goto found_device_id;
+ }
+
+ ret_status = pciFindDevice(PCIE_MAPLE_VENDOR_ID,
+ PCIE_MAPLE_EPON_DEVICE_ID,
+ pci_dev_idx,
+ &dev_info->pciBusNo,
+ &dev_info->pciDevNo,
+ &dev_info->pciFuncNo);
+
+ if (ret_status == OK)
+ {
+ device_id = PCIE_MAPLE_EPON_DEVICE_ID;
+ goto found_device_id;
+ }
+
+ printf("No more devices, Found %d maple device(s)\n", g_maple_dev_num);
+ break;
+
+found_device_id:
+ // Found new Maple device
+ printf("Found maple device[%x - %x][%d] @ Bus %d, Dev %d, Func %d\n",
+ PCIE_MAPLE_VENDOR_ID, PCIE_MAPLE_DEVICE_ID, pci_dev_idx,
+ dev_info->pciBusNo, dev_info->pciDevNo, dev_info->pciFuncNo);
+ g_maple_dev_num += 1;
+
+ // init
+ dev_info->deviceid = pci_dev_idx;
+ dev_info->pdev = NULL;
+
+
+ // Enable PCI address map
+ pciConfigInByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_COMMAND,
+ (UINT8 *)&readvalb);
+ printf("CMD reg = 0x%x\n", readvalb);
+
+ readvalb |= 0x6;
+ pciConfigOutByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_COMMAND,
+ (UINT8)readvalb);
+
+ pciConfigInByte(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_COMMAND,
+ (UINT8 *)&readvalb);
+ printf("Adjusted CMD reg = 0x%x\n", readvalb);
+
+ // Init base addresses
+
+#ifdef LLPCIE_SET_BASE_ADDRESSES_MANUALLY
+ dev_info->device.soc_regs_base = llpcie_base_addresses.soc_regs_base;
+ dev_info->device.soc_sram_base = llpcie_base_addresses.soc_sram_base;
+ dev_info->device.soc_ddr_base = llpcie_base_addresses.soc_ddr_base;
+ dev_info->device.soc_ddr_length = MAPLE_DDR_LENGTH; // 16M */
+#else
+ pciConfigInLong(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_BASE_ADDRESS_0,
+ (UINT32 *)&readval);
+ printf("BAR0 = 0x%x\n", readval);
+ dev_info->device.soc_regs_base = (readval & PCI_MEMBASE_MASK);
+
+ pciConfigInLong(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_BASE_ADDRESS_2,
+ (UINT32 *)&readval);
+ printf("BAR2 = 0x%x\n", readval);
+ dev_info->device.soc_ddr_base = (readval & PCI_MEMBASE_MASK);
+ dev_info->device.soc_ddr_length = MAPLE_DDR_LENGTH; // 16M
+
+ pciConfigInLong(dev_info->pciBusNo,
+ dev_info->pciDevNo,
+ dev_info->pciFuncNo,
+ PCI_CFG_BASE_ADDRESS_4,
+ (UINT32 *)&readval);
+ printf("BAR4 = 0x%x\n", readval);
+ dev_info->device.soc_sram_base = (readval & PCI_MEMBASE_MASK);
+#endif
+
+ printf("Regs Base = 0x%lx, DDR Base = 0x%lx, DDR Length = 0x%x, SRAM Base = 0x%lx\n",
+ dev_info->device.soc_regs_base,
+ dev_info->device.soc_ddr_base,
+ dev_info->device.soc_ddr_length,
+ dev_info->device.soc_sram_base);
+
+ // init interrupt
+ dev_info->device.irq = llpcie_device_irqs[pci_dev_idx].llpcie_irq;
+ dev_info->dev_status_irq = llpcie_device_irqs[pci_dev_idx].llpcie_status_irq;
+ printf("DMA IRQ = %d, Device status IRQ = %d\n",
+ dev_info->device.irq, dev_info->dev_status_irq);
+
+ // read revision register
+ readval = bcm_pci_read32((uint32_t *)(dev_info->device.soc_regs_base + PCIE_REVISION_REGISTER_OFFSET));
+ printf("readval = 0x%x\n", readval);
+ printf("Card %d version major=%02x minor=%02x\n",
+ dev_info->deviceid,
+ ((readval & 0x0000ff00) >> 8),
+ (readval & 0x000000ff));
+
+ // read status register
+ readval = bcm_pci_read32((uint32_t *)(dev_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET));
+ printf("readval = 0x%x\n", readval);
+ dev_info->err_status = (readval & 0x0000000f);
+ dev_info->phylink = ((readval >> 4) & 0x1);
+ dev_info->datalink = ((readval >> 5) & 0x1);
+ dev_info->prev_datalink = dev_info->datalink;
+
+ // connect INT for device status
+ bcmos_fastlock_init(&dev_info->lock, 0);
+ bcmos_int_connect((int)dev_info->dev_status_irq,
+ 0,
+ BCMOS_IRQ_SHARED,
+ dev_status_interrupt,
+ "status_isr",
+ dev_info);
+ }
+
+ // Return status
+ if (0 >=g_maple_dev_num)
+ {
+ return BCM_ERR_NODEV;
+ }
+ else
+ {
+ return BCM_ERR_OK;
+ }
+}
+
+/** Get Maple device object struct
+ * \crt devie index,start from 0
+ */
+static maple_device_info *get_maple_pci_info(int crt)
+{
+ bcmos_errno err = BCM_ERR_OK;
+ uint32_t readval = 0;
+ maple_device_info *device_info = NULL;
+
+ /* check input parameter */
+ /* don't access invalid device regs base address */
+ if (crt >= g_maple_dev_num)
+ {
+ return NULL;
+ }
+ device_info = &g_maple_devs_info[crt];
+
+ /* read status register */
+ readval = bcm_pci_read32((uint32_t *)(device_info->device.soc_regs_base + PCIE_STATUS_REGISTER_OFFSET));
+ device_info->err_status = (readval & 0x0000000f);
+ device_info->phylink = ((readval >> 4) & 0x1);
+ device_info->datalink = ((readval >> 5) & 0x1);
+
+ /* return device */
+ return device_info;
+}
+
+/** Register status change notification callback
+ * \param[in] cb Status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb)
+{
+ int i;
+ maple_device_info *dev_info;
+
+ g_dev_status_change_cb = cb;
+ for (i = 0; i < g_maple_dev_num; i++)
+ {
+ dev_info = get_maple_pci_info(i);
+ g_dev_status_change_cb(i, dev_info->datalink);
+ }
+
+ return BCM_ERR_OK;
+}
+
+/** Unregister status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_unregister(void)
+{
+ g_dev_status_change_cb = NULL;
+
+ return BCM_ERR_OK;
+}
+
+/** Query PCIe device
+ * \param[in] dev_id Device id
+ * \param[out] info Device info
+ * \return 0=OK, BCM_ERR_IO-dev_id is in proper range, but link is down
+ */
+bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info)
+{
+ maple_device_info *dev_info = NULL;
+
+ /* check input parameter */
+ if (NULL == info)
+ {
+ return BCM_ERR_PARM;
+ }
+
+ /* don't access invalid device regs base address */
+ if (dev_id < g_maple_dev_num)
+ {
+ dev_info = get_maple_pci_info(dev_id);
+ if (NULL == dev_info)
+ {
+ return BCM_ERR_NOENT;
+ }
+ if (dev_info->datalink == BCM_LL_PCIE_LINK_DOWN)
+ {
+ return BCM_ERR_IO;
+ }
+
+ *info = dev_info->device;
+ return BCM_ERR_OK;
+ }
+
+ return BCM_ERR_RANGE;
+}
+
+/** Get low-level device handle
+ * \param[in] dev_id Device id
+ * \param[out] lldev Low-level device handle
+ * \return device handle or NULL if link is down
+ */
+bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id)
+{
+ maple_device_info *dev_info = NULL;
+
+ /* check input parameter */
+ /* don't access invalid device regs base address */
+ if (dev_id < g_maple_dev_num)
+ {
+ dev_info = get_maple_pci_info(dev_id);
+ if (NULL == dev_info)
+ {
+ return NULL;
+ }
+ else
+ {
+ return dev_info->pdev;
+ }
+ }
+
+ return NULL;
+}
+
+/** Host reset enable
+ * \enabled
+ */
+bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled)
+{
+ uint32_t val;
+
+ /* check input parameter */
+ /* don't access invalid device regs base address */
+ if (dev_id >= g_maple_dev_num)
+ {
+ return BCM_ERR_OVERFLOW;
+ }
+
+ val = enabled ? 0 : 1;
+ bcm_pci_write32((uint32_t *)(g_maple_devs_info[dev_id].device.soc_regs_base + PCIE_HARD_DEBUG_REGISTER_OFFSET),
+ val);
+
+ return BCM_ERR_OK;
+}
+
diff --git a/bcm68620_release/release/host_customized/ll_pcie/vxworks/multi_device/bcmolt_llpcie.h b/bcm68620_release/release/host_customized/ll_pcie/vxworks/multi_device/bcmolt_llpcie.h
new file mode 100755
index 0000000..040d565
--- /dev/null
+++ b/bcm68620_release/release/host_customized/ll_pcie/vxworks/multi_device/bcmolt_llpcie.h
@@ -0,0 +1,105 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcm_llpcie.h - Low-level PCIe driver interface
+ */
+
+#ifndef BCMOLT_LLPCIE_H_
+#define BCMOLT_LLPCIE_H_
+
+#include "bcmos_system.h"
+#define BCMOLT_MAX_MAPLE_DEVICES 2 /* 5 */
+
+/** Low-level device info */
+typedef struct bcmolt_ll_dev_info
+{
+ unsigned long soc_regs_base; /**< Device registers base in host address space */
+ unsigned long soc_sram_base; /**< Device SRAM base in host address space */
+ unsigned long soc_ddr_base; /**< Device DDR base in host address space */
+ uint32_t soc_ddr_length; /**< Device DDR window size */
+ uint32_t irq; /**< Device irq number */
+} bcm_ll_dev_info;
+
+/** Device PCIe link status change notification callback */
+typedef enum
+{
+ BCM_LL_PCIE_LINK_DOWN, /**< PCIe link is down */
+ BCM_LL_PCIE_LINK_UP, /**< PCIe link is up */
+} bcm_ll_pcie_link_status;
+
+/** Low-level device handle */
+typedef void *bcm_ll_pcie_dev;
+
+/** Status change indication */
+typedef void (*bcm_ll_pcie_status_change)(uint8_t dev_id, bcm_ll_pcie_link_status status);
+
+/** Register status change notification callback
+ * \param[in] cb Status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_register(bcm_ll_pcie_status_change cb);
+
+/** Unregister status change notification callback
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_status_change_unregister(void);
+
+/** Query PCIe device
+ * \param[in] dev_id Device id
+ * \param[out] info Device info
+ * \return 0=OK, BCM_ERR_IO-dev_id is in proper range, but link is down
+ */
+bcmos_errno bcm_ll_pcie_query(uint8_t dev_id, bcm_ll_dev_info *info);
+
+/** Get low-level device handle
+ * \param[in] dev_id Device id
+ * \param[out] lldev Low-level device handle
+ * \return device handle or NULL if link is down
+ */
+bcm_ll_pcie_dev bcm_ll_pcie_dev_get(uint8_t dev_id);
+
+/** Enable/disable host reset for all PCIe interfaces (automatic
+ * device reset when host is reset)
+ * \param[in] enabled Whether or not hot reset should be enabled
+ * \return 0=OK or error <0
+ */
+bcmos_errno bcm_ll_pcie_host_reset_enable(uint8_t dev_id, bcmos_bool enabled);
+
+#ifdef TX_ENABLE_EVENT_TRACE
+/** Handle low-level trace on target
+ * \param[in] dev_id Device id
+ * \param[in] lfile name for trace
+ * \return device handle or NULL if link is down
+ */
+bcmos_errno bcm_ll_pcie_setrace(uint8_t dev_id);
+bcmos_errno bcm_ll_pcie_cleartrace(uint8_t dev_id);
+bcmos_errno bcm_ll_pcie_savetrace(uint8_t dev_id, char *tracefilename);
+#endif
+#endif
diff --git a/bcm68620_release/release/host_customized/model_linux/Makefile b/bcm68620_release/release/host_customized/model_linux/Makefile
new file mode 100644
index 0000000..45c5c31
--- /dev/null
+++ b/bcm68620_release/release/host_customized/model_linux/Makefile
@@ -0,0 +1,19 @@
+# Makefile for building system model as linux module
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = sysmodel
+MOD_DEPS = utils common_api
+MOD_TYPE = linux_lib
+SRC_DIR = $(MODEL_OUT_DIR)/linux
+srcs = bcmolt_model_types.c bcmolt_msg_pack.c
+
+$(shell mkdir -p $(SRC_DIR); ln -s $(MODEL_OUT_DIR)/*.[ch] $(SRC_DIR)/ 2> /dev/null)
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/Makefile b/bcm68620_release/release/host_customized/os_abstraction/Makefile
new file mode 100644
index 0000000..258f45f
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/Makefile
@@ -0,0 +1,51 @@
+# OS abstraction layer
+#
+MOD_NAME = os
+MOD_TYPE = lib
+MOD_INC_DIRS = $(SRC_DIR) $(SRC_DIR)/$(OS)
+MOD_INC_DIRS += $(OS_PLATFORM_DIR) $(CONFIG_DIR)
+MOD_SUPPRESS_OS_DEP = y
+
+ifeq ("$(OS)", "threadx")
+ MOD_DEPS = threadx bsp
+ MOD_INC_DIRS += $(SUBSYSTEM)/sys/inc
+ MOD_DEFS = -DBCMOS_TRACE_IN_DEV_LOG
+endif
+
+ifeq ("$(OS)", "posix")
+ ENABLE_MSG_QUEUE_DOMAIN_SOCKET ?= y
+ ENABLE_MSG_QUEUE_UDP_SOCKET ?= y
+endif
+
+ifeq ("$(ENABLE_MSG_QUEUE_DOMAIN_SOCKET)", "y")
+ MOD_DEFS += -DBCMOS_MSG_QUEUE_DOMAIN_SOCKET
+endif
+
+ifeq ("$(ENABLE_MSG_QUEUE_UDP_SOCKET)", "y")
+ MOD_DEFS += -DBCMOS_MSG_QUEUE_UDP_SOCKET
+endif
+
+ifeq ("$(BUF_IN_DMA_MEM)", "y")
+ EXTRA_CFLAGS += -DBCMOS_BUF_IN_DMA_MEM
+ BUF_DATA_UNIT_SIZE ?= 1024
+ EXTRA_CFLAGS += -DBCMOS_BUF_DATA_UNIT_SIZE=$(BUF_DATA_UNIT_SIZE)
+endif
+
+ifneq ("$(BUF_POOL_SIZE)", "")
+ ifeq ("$(BUF_POOL_BUF_SIZE)", "")
+ BUF_POOL_BUF_SIZE = 4096
+ endif
+ EXTRA_CFLAGS += -DBCMOS_BUF_POOL_SIZE=$(BUF_POOL_SIZE) -DBCMOS_BUF_POOL_BUF_SIZE=$(BUF_POOL_BUF_SIZE)
+endif
+
+srcs = bcmos_common.c bcmos_errno.c bcmos_hash_table.c bcmos_rw_lock.c $(OS)/bcmos_system.c
+
+ifeq ("$(DEBUG)", "y")
+ MOD_DEFS += -DBCMOS_MEM_DEBUG -DBCMOS_SYS_UNITTEST
+endif
+
+ifeq ("$(SUBSYSTEM)", "embedded")
+ USE_LINT = yes
+endif
+
+#EXTRA_DEFINES += -DBCMOS_SYS_UNITTEST
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_common.c b/bcm68620_release/release/host_customized/os_abstraction/bcmos_common.c
new file mode 100644
index 0000000..d2d552a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_common.c
@@ -0,0 +1,2772 @@
+/*
+<: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"
+
+/* task control blocks */
+STAILQ_HEAD(task_list, bcmos_task) task_list = STAILQ_HEAD_INITIALIZER(task_list);
+
+/* module control blocks */
+bcmos_module *bcmos_modules[BCMOS_MODULE_ID__NUM_OF];
+
+/* event control blocks */
+bcmos_event *bcmos_events[BCMOS_EVENT_ID__NUM_OF];
+
+/* Global trace level */
+bcmos_trace_level bcmos_sys_trace_level = BCMOS_TRACE_LEVEL_ERROR;
+
+/* Global OS mutex */
+bcmos_mutex bcmos_res_lock;
+
+/* Total memory occupied by block pools */
+uint32_t bcmos_total_blk_pool_size;
+
+/* Total memory occupied by message pools */
+uint32_t bcmos_total_msg_pool_size;
+
+f_bcmolt_sw_error_handler sw_error_handler;
+
+/* Block pools */
+static STAILQ_HEAD(blk_pool_list, bcmos_blk_pool) blk_pool_list = STAILQ_HEAD_INITIALIZER(blk_pool_list);
+
+/* Message pools */
+static STAILQ_HEAD(msg_pool_list, bcmos_blk_pool) msg_pool_list = STAILQ_HEAD_INITIALIZER(msg_pool_list);
+
+/* Message queues */
+static STAILQ_HEAD(msg_queue_list, bcmos_msg_queue) msg_queue_list = STAILQ_HEAD_INITIALIZER(msg_queue_list);
+
+/* Message queue groups */
+static STAILQ_HEAD(msg_qgroup_list, bcmos_msg_qgroup) msg_qgroup_list = STAILQ_HEAD_INITIALIZER(msg_qgroup_list);
+
+/* Lock used to protect msg registration / deregistration */
+static bcmos_fastlock bcmos_msg_register_lock;
+
+/* Shutdown mode: when this is set, we expect message handler deregistration to happen while messages are still being
+ * sent/received. We should handle this gracefully. */
+static bcmos_bool bcmos_msg_shutdown_mode = BCMOS_FALSE;
+
+/* Timer management block */
+typedef struct bcmos_timer_pool
+{
+ bcmos_fastlock lock; /* Pool protection lock */
+ bcmos_sys_timer sys_timer; /* System timer handle */
+ uint32_t num_active_timers; /* Number of active timers in the pool */
+#ifdef BCMOS_TIMER_RB_TREE
+ RB_HEAD(bcmos_timers, bcmos_timer) pool; /* Timer pool. RB tree */
+#else
+ TAILQ_HEAD(bcmos_timers, bcmos_timer) pool; /* Timer pool: TAILQ */
+#endif
+} bcmos_timer_pool;
+
+static int32_t _bcmos_timer_compare(bcmos_timer *t1, bcmos_timer *t2);
+
+/*
+ * Macros for RB-TREE and TAILQ-based timer tool implementations
+ */
+
+#ifdef BCMOS_TIMER_RB_TREE
+
+#ifdef __arm__
+/* ARM compiler doesn't like unused inline functions. Disable the warning */
+#pragma diag_suppress 177
+#endif
+
+/* Generate RB tree functions */
+RB_GENERATE_INLINE(bcmos_timers, bcmos_timer, entry, _bcmos_timer_compare)
+
+#define TMR_POOL_INIT(tmr_pool) RB_INIT(&(tmr_pool)->pool)
+#define TMR_POOL_INSERT(tmr_pool, tmr) RB_INSERT(bcmos_timers, &(tmr_pool)->pool, tmr)
+#define TMR_POOL_REMOVE(tmr_pool, tmr) RB_REMOVE(bcmos_timers, &(tmr_pool)->pool, tmr)
+#define TMR_POOL_FIRST(tmr_pool) RB_MIN(bcmos_timers, &(tmr_pool)->pool)
+
+#else
+
+#define TMR_POOL_INIT(tmr_pool) TAILQ_INIT(&(tmr_pool)->pool)
+
+#define TMR_POOL_INSERT(tmr_pool, tmr) \
+ do { \
+ bcmos_timer *_last = TAILQ_LAST(&(tmr_pool)->pool, bcmos_timers); \
+ if (_last) \
+ { \
+ if (_bcmos_timer_compare(tmr, _last) >= 0) \
+ { \
+ TAILQ_INSERT_TAIL(&(tmr_pool)->pool, tmr, entry); \
+ } \
+ else \
+ { \
+ bcmos_timer *_t; \
+ uint32_t iter = 0; \
+ TAILQ_FOREACH(_t, &(tmr_pool)->pool, entry) \
+ { \
+ BUG_ON(iter >= (tmr_pool)->num_active_timers);\
+ ++iter; \
+ if (_bcmos_timer_compare(tmr, _t) <= 0) \
+ { \
+ TAILQ_INSERT_BEFORE(_t, tmr, entry); \
+ break; \
+ } \
+ } \
+ } \
+ } \
+ else \
+ { \
+ TAILQ_INSERT_HEAD(&(tmr_pool)->pool, tmr, entry); \
+ } \
+ ++(tmr_pool)->num_active_timers; \
+ } while (0)
+
+#define TMR_POOL_REMOVE(tmr_pool, tmr) \
+ do { \
+ BUG_ON(!(tmr_pool)->num_active_timers); \
+ TAILQ_REMOVE(&(tmr_pool)->pool, tmr, entry); \
+ TAILQ_NEXT(tmr, entry) = NULL; \
+ --(tmr_pool)->num_active_timers; \
+ } while (0)
+
+#define TMR_POOL_FIRST(tmr_pool) TAILQ_FIRST(&(tmr_pool)->pool)
+
+#endif
+
+#define BCMOS_TIMER_IS_RUNNING(tmr) ((tmr->flags & BCMOS_TIMER_FLAG_RUNNING) != 0)
+#define BCMOS_TIMER_IS_EXPIRED(tmr) ((tmr->flags & BCMOS_TIMER_FLAG_EXPIRED) != 0)
+#define BCMOS_TIMER_IS_VALID(tmr) ((tmr->flags & BCMOS_TIMER_FLAG_VALID) != 0)
+#define BCMOS_TIMER_IS_ACTIVE(tmr) ((tmr->flags & BCMOS_TIMER_FLAG_ACTIVE) != 0)
+
+static bcmos_bool bcmos_initialized;
+static bcmos_timer_pool tmr_pool;
+static void _sys_timer_handler(void *data);
+
+/*
+ * Print variables
+ */
+
+static bcmos_print_redirect_mode print_redirect_mode;
+static bcmos_print_redirect_cb print_redirect_cb;
+static void *print_redirect_cb_data;
+static bcmos_mutex bcmos_print_lock;
+#ifdef BCMOS_BUF_POOL_SIZE
+static bcmos_blk_pool sys_buf_pool;
+static bcmos_errno bcmos_buf_pool_create(void);
+#endif
+
+/** Initialize system library
+ * \ingroup system
+ * Must be called before any other system function
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_init(void)
+{
+ bcmos_errno rc;
+
+ if (bcmos_initialized)
+ return BCM_ERR_OK;
+ rc = bcmos_sys_init();
+ bcmos_mutex_create(&bcmos_res_lock, 0, "res_lock");
+ bcmos_mutex_create(&bcmos_print_lock, 0, "print_lock");
+ TMR_POOL_INIT(&tmr_pool);
+ bcmos_fastlock_init(&tmr_pool.lock, 0);
+ bcmos_fastlock_init(&bcmos_msg_register_lock, 0);
+ rc = rc ? rc : bcmos_sys_timer_create(&tmr_pool.sys_timer, _sys_timer_handler, &tmr_pool);
+
+ /* Create default buffer pool if so requested by compilation options */
+#ifdef BCMOS_BUF_POOL_SIZE
+ rc = rc ? rc : bcmos_buf_pool_create();
+#endif
+
+ if (!rc)
+ {
+ bcmos_initialized = BCMOS_TRUE;
+ }
+
+ return rc;
+}
+
+/** Cleanup system library
+ * \ingroup system
+ */
+void bcmos_exit(void)
+{
+ if (!bcmos_initialized)
+ return;
+ bcmos_sys_timer_destroy(&tmr_pool.sys_timer);
+ bcmos_mutex_destroy(&bcmos_print_lock);
+ bcmos_mutex_destroy(&bcmos_res_lock);
+#ifdef BCMOS_BUF_POOL_SIZE
+ bcmos_blk_pool_reset(&sys_buf_pool);
+ bcmos_blk_pool_destroy(&sys_buf_pool);
+#endif
+ bcmos_sys_exit();
+ bcmos_initialized = BCMOS_FALSE;
+}
+
+/*
+ * Common task services
+ */
+
+/* Query task info */
+bcmos_errno bcmos_task_query(const bcmos_task *task, bcmos_task_parm *parm)
+{
+ if (task == NULL || task->magic != BCMOS_TASK_MAGIC || parm == NULL)
+ {
+ return BCM_ERR_PARM;
+ }
+ *parm = task->parm;
+ return BCM_ERR_OK;
+}
+
+/** Task iterator
+ * \param[in] prev Previous task. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_task_get_next(bcmos_task **prev)
+{
+ bcmos_task *task;
+ if (prev == NULL)
+ {
+ return BCM_ERR_PARM;
+ }
+ task = *prev;
+ if (task && task->magic != BCMOS_TASK_MAGIC)
+ {
+ return BCM_ERR_PARM;
+ }
+ if (task)
+ {
+ task = STAILQ_NEXT(task, list);
+ }
+ else
+ {
+ task = STAILQ_FIRST(&task_list);
+ }
+ *prev = task;
+ if (!task)
+ {
+ return BCM_ERR_NO_MORE;
+ }
+ return BCM_ERR_OK;
+}
+
+/*
+ * Message queue
+ */
+
+static void _bcmos_msgq_notify(bcmos_msg_queue *q, const char *txt)
+{
+ BCMOS_TRACE_INFO("Msg queue %s: %s\n", q->q.parm.name, txt);
+}
+
+/* Decrement in-queue statistics */
+static inline void _bcmos_msgq_stat_dec(bcmos_msg_queue_nw *q)
+{
+ bcmos_msg_queue_stat *stat = &q->stat;
+ uint32_t old_in = stat->msg_in;
+
+ if (stat->msg_in == 0)
+ {
+ BCMOS_TRACE_ERR("Attempt to decrement statistics for an empty queue ('%s')\n", q->parm.name);
+ }
+ else
+ {
+ --stat->msg_in;
+ ++stat->msg_received;
+ }
+
+ if (old_in == q->parm.low_wm)
+ {
+ q->parm.notify((bcmos_msg_queue *)q, "becomes uncongested");
+ stat->is_congested = BCMOS_FALSE;
+ }
+}
+
+/* Increment in-queue statistics */
+static inline void _bcmos_msgq_stat_inc(bcmos_msg_queue_nw *q)
+{
+ bcmos_msg_queue_stat *stat = &q->stat;
+ uint32_t old_in = stat->msg_in;
+
+ ++stat->msg_in;
+ ++stat->msg_sent;
+ if (old_in == q->parm.high_wm)
+ {
+ q->parm.notify((bcmos_msg_queue *)q, "becomes congested");
+ stat->is_congested = BCMOS_TRUE;
+ }
+ if (stat->is_congested)
+ ++stat->msg_almost_full;
+}
+
+static void _bcmos_qgroup_notify(bcmos_msg_qgroup *qgroup, const char *txt)
+{
+ BCMOS_TRACE_INFO("Msg queue %s: %s\n", qgroup->parm.name, txt);
+}
+
+/* Decrement in-queue statistics for queue group */
+static inline void _bcmos_qgroup_stat_dec(bcmos_msg_qgroup *qgroup)
+{
+ bcmos_msg_queue_stat *stat = &qgroup->stat;
+ uint32_t old_in = stat->msg_in;
+
+ if (stat->msg_in == 0)
+ {
+ BCMOS_TRACE_ERR("Attempt to decrement statistics for an empty queue ('%s')\n", qgroup->parm.name);
+ }
+ else
+ {
+ --stat->msg_in;
+ ++stat->msg_received;
+ }
+
+ if (old_in == qgroup->parm.low_wm)
+ {
+ qgroup->parm.notify(qgroup, "becomes uncongested");
+ stat->is_congested = BCMOS_FALSE;
+ }
+}
+
+/* Increment in-queue statistics */
+static inline void _bcmos_qgroup_stat_inc(bcmos_msg_qgroup *qgroup)
+{
+ bcmos_msg_queue_stat *stat = &qgroup->stat;
+ uint32_t old_in = stat->msg_in;
+
+ ++stat->msg_in;
+ ++stat->msg_sent;
+ if (old_in == qgroup->parm.high_wm)
+ {
+ qgroup->parm.notify(qgroup, "becomes congested");
+ stat->is_congested = BCMOS_TRUE;
+ }
+ if (stat->is_congested)
+ ++stat->msg_almost_full;
+}
+
+
+/* Get message from queue.
+ * Urgent queue is checked 1st, then regular queue
+ * Must be called under lock!
+ * Returns msg or NULL if queue is empty
+ */
+static inline bcmos_msg *_bcmos_msg_get(bcmos_msg_queue_nw *q)
+{
+ bcmos_msg *msg;
+
+ msg = STAILQ_FIRST(&q->msgl_urg);
+ if (msg)
+ {
+ STAILQ_REMOVE_HEAD(&q->msgl_urg, next);
+ _bcmos_msgq_stat_dec(q);
+ return msg;
+ }
+
+ msg = STAILQ_FIRST(&q->msgl);
+ if (msg)
+ {
+ STAILQ_REMOVE_HEAD(&q->msgl, next);
+ _bcmos_msgq_stat_dec(q);
+ }
+
+ return msg;
+}
+
+/* Put message on queue.
+ * Must be called under lock!
+ * Returns error in case of queue overflow
+ */
+static inline bcmos_errno _bcmos_msg_put(bcmos_msg_queue_nw *q, bcmos_msg *msg, bcmos_msg_send_flags flags)
+{
+ /* Overflow check */
+ if (q->stat.msg_in >= q->parm.size)
+ {
+ if (!(flags & BCMOS_MSG_SEND_NOLIMIT))
+ {
+ ++q->stat.msg_discarded;
+ return BCM_ERR_OVERFLOW;
+ }
+ }
+ /* Put onto the relevant queue */
+ if ((flags & BCMOS_MSG_SEND_URGENT))
+ STAILQ_INSERT_TAIL(&q->msgl_urg, msg, next);
+ else
+ STAILQ_INSERT_TAIL(&q->msgl, msg, next);
+ _bcmos_msgq_stat_inc(q);
+
+ return BCM_ERR_OK;
+}
+
+/* Create message queue without wait support */
+static void bcmos_msg_queue_nw_init(bcmos_msg_queue_nw *q, const bcmos_msg_queue_parm *parm)
+{
+ q->parm = *parm;
+ STAILQ_INIT(&q->msgl);
+ STAILQ_INIT(&q->msgl_urg);
+ bcmos_fastlock_init(&q->lock, parm->flags);
+ memset(&q->stat, 0, sizeof(q->stat));
+ q->flags = 0;
+ if (!q->parm.size)
+ q->parm.size = BCMOS_MSG_QUEUE_SIZE_UNLIMITED;
+ if (!q->parm.high_wm)
+ q->parm.high_wm = BCMOS_MSG_QUEUE_SIZE_UNLIMITED;
+ if (!q->parm.low_wm)
+ q->parm.low_wm = q->parm.high_wm;
+ if (!q->parm.notify)
+ q->parm.notify = _bcmos_msgq_notify;
+}
+
+/* Destroy message list */
+static void bcmos_msg_list_destroy(bcmos_msg_list *l)
+{
+ bcmos_msg *msg, *tmp;
+ STAILQ_FOREACH_SAFE(msg, l, next, tmp)
+ {
+ STAILQ_REMOVE_HEAD(l, next);
+ bcmos_msg_free(msg);
+ }
+}
+
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+
+/* Remote queue support - common part of create/destroy */
+
+static bcmos_errno _bcmos_msg_queue_destroy_remote_ep(bcmos_msg_queue *queue)
+{
+ if (queue->q.parm.close)
+ queue->q.parm.close(queue);
+ bcmos_mutex_destroy(&queue->send_lock);
+ if (queue->send_buf)
+ bcmos_free(queue->send_buf);
+ if (queue->recv_buf)
+ bcmos_free(queue->recv_buf);
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno _bcmos_msg_queue_create_remote_ep(bcmos_msg_queue *queue)
+{
+ bcmos_errno rc;
+
+ /* Allocate tx and rx buffers */
+ if (!queue->q.parm.max_mtu)
+ {
+ queue->q.parm.max_mtu = BCMOS_MSG_QUEUE_DEFAULT_MAX_MTU;
+ }
+ queue->send_buf = bcmos_calloc(queue->q.parm.max_mtu);
+ if (!queue->send_buf)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "Can't allocate send_buf\n");
+ }
+
+ queue->recv_buf = bcmos_calloc(queue->q.parm.max_mtu);
+ if (!queue->recv_buf)
+ {
+ bcmos_free(queue->send_buf);
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "Can't allocate recv_buf\n");
+ }
+ bcmos_mutex_create(&queue->send_lock, 0, queue->q.parm.name);
+
+ switch (queue->q.parm.ep_type)
+ {
+#ifdef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+ case BCMOS_MSG_QUEUE_EP_DOMAIN_SOCKET:
+ rc = bcmos_sys_msg_queue_domain_socket_open(queue);
+ break;
+#endif
+#ifdef BCMOS_MSG_QUEUE_UDP_SOCKET
+ case BCMOS_MSG_QUEUE_EP_UDP_SOCKET:
+ rc = bcmos_sys_msg_queue_udp_socket_open(queue);
+ break;
+#endif
+#ifdef BCMOS_MSG_QUEUE_USER_DEFINED
+ case BCMOS_MSG_QUEUE_EP_USER_DEFINED:
+ if (parm.open == NULL || parm.close == NULL || parm.send==NULL || parm.recv == NULL)
+ {
+ rc = BCM_ERR_PARM;
+ break;
+ }
+ rc = parm.open(queue);
+ break;
+#endif
+ default:
+ rc = BCM_ERR_PARM;
+ break;
+ }
+
+ if (rc)
+ {
+ _bcmos_msg_queue_destroy_remote_ep(queue);
+ }
+
+ return rc;
+}
+
+#endif /* #ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT */
+
+/* Create message queue. */
+bcmos_errno bcmos_msg_queue_create(bcmos_msg_queue *queue, const bcmos_msg_queue_parm *parm)
+{
+ bcmos_errno rc;
+
+ if (!queue || !parm)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "queue %p, parm %p\n", queue, parm);
+ memset(queue, 0, sizeof(*queue));
+ queue->q.parm = *parm;
+
+ if (parm->ep_type == BCMOS_MSG_QUEUE_EP_LOCAL)
+ {
+ rc = bcmos_sem_create(&queue->m, 0, parm->flags, queue->q.parm.name);
+ if (!rc)
+ bcmos_msg_queue_nw_init(&queue->q, parm);
+ }
+ else
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+ {
+ rc = _bcmos_msg_queue_create_remote_ep(queue);
+ }
+#else
+ {
+ rc = BCM_ERR_PARM;
+ }
+#endif
+
+ if (rc)
+ return rc;
+
+ queue->magic = BCMOS_MSG_QUEUE_VALID;
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (queue->q.parm.name)
+ {
+ strncpy(queue->name, queue->q.parm.name, sizeof(queue->name) - 1);
+ queue->q.parm.name = queue->name;
+ }
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&msg_queue_list, queue, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ return BCM_ERR_OK;
+}
+
+/* Destroy queue */
+bcmos_errno bcmos_msg_queue_destroy(bcmos_msg_queue *queue)
+{
+ bcmos_errno rc = BCM_ERR_OK;
+
+ if (!queue || queue->magic != BCMOS_MSG_QUEUE_VALID)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "queue handle is invalid\n");
+ }
+ queue->magic = BCMOS_MSG_QUEUE_DELETED;
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&msg_queue_list, queue, bcmos_msg_queue, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+
+ if (queue->q.parm.ep_type == BCMOS_MSG_QUEUE_EP_LOCAL)
+ {
+ bcmos_sem_destroy(&queue->m);
+ /* Release all pending messages */
+ bcmos_msg_list_destroy(&queue->q.msgl_urg);
+ bcmos_msg_list_destroy(&queue->q.msgl);
+ }
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+ else
+ {
+ rc = _bcmos_msg_queue_destroy_remote_ep(queue);
+ }
+#endif
+
+ return rc;
+}
+
+/* Get queue info */
+bcmos_errno bcmos_msg_queue_query(const bcmos_msg_queue *queue, bcmos_msg_queue_info *info)
+{
+ if (!queue || !info)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "queue %p, info %p\n", queue, info);
+ info->stat = queue->q.stat;
+ info->parm = queue->q.parm;
+ return BCM_ERR_OK;
+}
+
+/* Message queue iterator */
+bcmos_errno bcmos_msg_queue_get_next(const bcmos_msg_queue **prev)
+{
+ const bcmos_msg_queue *queue;
+
+ if (prev == NULL)
+ {
+ return BCM_ERR_PARM;
+ }
+ queue = *prev;
+ if (queue && queue->magic != BCMOS_MSG_QUEUE_VALID)
+ {
+ return BCM_ERR_PARM;
+ }
+ if (queue)
+ {
+ queue = STAILQ_NEXT(queue, list);
+ }
+ else
+ {
+ queue = STAILQ_FIRST(&msg_queue_list);
+ }
+ *prev = queue;
+ if (!queue)
+ {
+ return BCM_ERR_NO_MORE;
+ }
+ return BCM_ERR_OK;
+}
+
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+
+/* Pack / unpack message header.
+ * In the future we might adopt bcmolt_buf service into OS abstraction and use it
+ * for packing / unpacking.
+ */
+
+void bcmos_msg_hdr_pack(const bcmos_msg *msg, uint8_t *buf, uint32_t data_size)
+{
+ uint16_t val16;
+ uint32_t val32;
+ val16 = BCMOS_ENDIAN_CPU_TO_BIG_U16(msg->type);
+ memcpy(buf, &val16, sizeof(val16));
+ buf[2] = (uint8_t)msg->instance;
+ buf[3] = (uint8_t)msg->sender;
+ val32 = BCMOS_ENDIAN_CPU_TO_BIG_U32(data_size);
+ memcpy(&buf[4], &val32, sizeof(val32));
+}
+
+void bcmos_msg_hdr_unpack(const uint8_t *buf, bcmos_msg *msg)
+{
+ uint16_t val16;
+ uint32_t val32;
+ memcpy(&val16, buf, sizeof(val16));
+ val16 = BCMOS_ENDIAN_BIG_TO_CPU_U16(val16);
+ msg->type = (bcmos_msg_id)val16;
+ msg->instance = (bcmos_msg_instance)buf[2];
+ msg->sender = (bcmos_module_id)buf[3];
+ memcpy(&val32, &buf[4], sizeof(val32));
+ msg->size = BCMOS_ENDIAN_BIG_TO_CPU_U32(val32); /* can be overwritten by unpacker */
+ msg->handler = NULL;
+ msg->send_flags = 0;
+}
+
+/* Send message to remote EP wrapper */
+static bcmos_errno _bcmos_msg_send_to_remote_ep(bcmos_msg_queue *queue, bcmos_msg *msg, bcmos_msg_send_flags flags)
+{
+ uint8_t *buf = NULL;
+ uint32_t buf_length = 0;
+ bcmos_errno rc;
+
+ bcmos_mutex_lock(&queue->send_lock);
+ rc = queue->q.parm.pack(queue, msg, &buf, &buf_length);
+ rc = rc ? rc : queue->q.parm.send(queue, buf, buf_length);
+ bcmos_mutex_unlock(&queue->send_lock);
+
+ /* Release if sent successfully or if auto-release flag is set */
+ if (rc == BCM_ERR_OK || !(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ {
+ bcmos_msg_free(msg);
+ }
+ if (buf && queue->q.parm.free_packed)
+ {
+ queue->q.parm.free_packed(queue, buf);
+ }
+ if (rc)
+ {
+ ++queue->q.stat.msg_discarded;
+ }
+ else
+ {
+ ++queue->q.stat.msg_sent;
+ }
+
+ return rc;
+}
+
+/* Receive message from remote EP wrapper */
+static bcmos_errno _bcmos_msg_recv_from_remote_ep(bcmos_msg_queue *queue, uint32_t timeout, bcmos_msg **msg)
+{
+ uint8_t *buf = NULL;
+ uint32_t buf_length = 0;
+ bcmos_errno rc;
+
+ rc = queue->q.parm.recv(queue, timeout, &buf, &buf_length);
+ rc = rc ? rc : queue->q.parm.unpack(queue, buf, buf_length, msg);
+ if (buf && queue->q.parm.free_packed)
+ {
+ queue->q.parm.free_packed(queue, buf);
+ }
+ if (!rc)
+ {
+ ++queue->q.stat.msg_received;
+ }
+
+ return rc;
+}
+
+#endif /* BCMOS_MSG_QUEUE_REMOTE_SUPPORT */
+
+/* Send message to queue */
+bcmos_errno bcmos_msg_send(bcmos_msg_queue *queue, bcmos_msg *msg, bcmos_msg_send_flags flags)
+{
+ long lock_flags;
+ bcmos_errno rc;
+
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+ if (queue->q.parm.ep_type != BCMOS_MSG_QUEUE_EP_LOCAL)
+ {
+ return _bcmos_msg_send_to_remote_ep(queue, msg, flags);
+ }
+#endif
+
+ lock_flags = bcmos_fastlock_lock(&queue->q.lock);
+ rc = _bcmos_msg_put(&queue->q, msg, flags);
+ if (rc)
+ {
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+ if (!(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ {
+ bcmos_msg_free(msg);
+ }
+ BCMOS_TRACE_ERR("Overflow: Queue %s\n", queue->q.parm.name);
+ return rc;
+ }
+
+ /* Success */
+ if (queue->is_waiting)
+ {
+ /* Kick waiting task */
+ queue->is_waiting = BCMOS_FALSE;
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+ bcmos_sem_post(&queue->m);
+ }
+ else
+ {
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+ }
+
+ return BCM_ERR_OK;
+}
+
+/* Send message to module (internal) - doesn't post any semaphores so it's safe to call under a fastlock */
+static bcmos_errno _bcmos_msg_send_to_module(
+ bcmos_module_id module_id,
+ bcmos_msg *msg,
+ bcmos_msg_send_flags flags,
+ bcmos_sem **sem_to_post)
+{
+ bcmos_module *module = _bcmos_module_get(module_id);
+ bcmos_task *task;
+ long lock_flags, q_lock_flags;
+ uint32_t active_modules;
+ bcmos_errno rc;
+ *sem_to_post = NULL;
+
+ if (!module || !msg->handler)
+ {
+ if (!module)
+ {
+ BCMOS_TRACE_ERR("Module %d doesn't exist\n", module_id);
+ rc = BCM_ERR_NOENT;
+ }
+ else
+ {
+ BCMOS_TRACE_ERR("msg->handler is not set. msg->type=%d\n", msg->type);
+ rc = BCM_ERR_PARM;
+ }
+ if (!(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ {
+ bcmos_msg_free(msg);
+ }
+ return rc;
+ }
+
+ task = module->my_task;
+ lock_flags = bcmos_fastlock_lock(&task->active_lock);
+ q_lock_flags = bcmos_fastlock_lock(&module->msgq.lock);
+
+ rc = _bcmos_msg_put(&module->msgq, msg, flags);
+ if (rc)
+ {
+ bcmos_fastlock_unlock(&module->msgq.lock, q_lock_flags);
+ bcmos_fastlock_unlock(&task->active_lock, lock_flags);
+
+ /* Queue overflow */
+ if (!(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ bcmos_msg_free(msg);
+
+ BCMOS_TRACE_ERR("Overflow: Queue %s\n", module->parm.qparm.name);
+
+ return rc;
+ }
+ bcmos_fastlock_unlock(&module->msgq.lock, q_lock_flags);
+
+ /* Success. Update active_modules task and kick the task */
+ active_modules = task->active_modules;
+ task->active_modules |= (1 << module->idx);
+ bcmos_fastlock_unlock(&task->active_lock, lock_flags);
+
+ /* Notify caller to kick task if there is a chance it was waiting */
+ if (!active_modules)
+ *sem_to_post = &task->active_sem;
+
+ return BCM_ERR_OK;
+}
+
+/* Send message to module */
+bcmos_errno bcmos_msg_send_to_module(bcmos_module_id module_id, bcmos_msg *msg, bcmos_msg_send_flags flags)
+{
+ bcmos_sem *sem_to_post;
+ bcmos_errno err = _bcmos_msg_send_to_module(module_id, msg, flags, &sem_to_post);
+ if (sem_to_post)
+ bcmos_sem_post(sem_to_post);
+ return err;
+}
+
+/* Get message from the head of message queue */
+bcmos_errno bcmos_msg_recv(bcmos_msg_queue *queue, uint32_t timeout, bcmos_msg **msg)
+{
+ long lock_flags;
+
+ if (!queue || !msg)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "queue %p, msg %p\n", queue, msg);
+
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+ if (queue->q.parm.ep_type != BCMOS_MSG_QUEUE_EP_LOCAL)
+ {
+ return _bcmos_msg_recv_from_remote_ep(queue, timeout, msg);
+ }
+#endif
+
+ lock_flags = bcmos_fastlock_lock(&queue->q.lock);
+ *msg = _bcmos_msg_get(&queue->q);
+ if (*msg)
+ {
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+ return BCM_ERR_OK;
+ }
+ if (!timeout)
+ {
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+ return BCM_ERR_NOENT;
+ }
+
+ /* Receive with wait */
+ queue->is_waiting = BCMOS_TRUE;
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+
+ /* wait for it */
+ bcmos_sem_wait(&queue->m, timeout);
+ lock_flags = bcmos_fastlock_lock(&queue->q.lock);
+ *msg = _bcmos_msg_get(&queue->q);
+ queue->is_waiting = BCMOS_FALSE;
+ bcmos_fastlock_unlock(&queue->q.lock, lock_flags);
+ if (!*msg)
+ return BCM_ERR_TIMEOUT;
+
+ return BCM_ERR_OK;
+}
+
+
+/*
+ * Queue group support
+ */
+
+/* Create message queue group. */
+bcmos_errno bcmos_msg_qgroup_create(bcmos_msg_qgroup *qgroup, const bcmos_msg_qgroup_parm *parm)
+{
+ bcmos_errno rc;
+ bcmos_qgroup_prty prty;
+
+ if (!qgroup || !parm || !parm->nqueues || parm->nqueues>32)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "queue %p, parm %p nqueues %u\n", qgroup, parm, parm ? parm->nqueues: 0);
+ memset(qgroup, 0, sizeof(*qgroup));
+ rc = bcmos_sem_create(&qgroup->m, 0, parm->flags, NULL);
+ if (rc)
+ return rc;
+ qgroup->parm = *parm;
+ bcmos_fastlock_init(&qgroup->lock, parm->flags);
+ if (!qgroup->parm.size)
+ qgroup->parm.size = BCMOS_MSG_QUEUE_SIZE_UNLIMITED;
+ if (!qgroup->parm.high_wm)
+ qgroup->parm.high_wm = BCMOS_MSG_QUEUE_SIZE_UNLIMITED;
+ if (!qgroup->parm.low_wm)
+ qgroup->parm.low_wm = qgroup->parm.high_wm;
+ if (!qgroup->parm.notify)
+ qgroup->parm.notify = _bcmos_qgroup_notify;
+ qgroup->msgl = bcmos_calloc(sizeof(bcmos_msg_list) * (uint32_t)parm->nqueues);
+ if (!qgroup->msgl)
+ {
+ bcmos_msg_qgroup_destroy(qgroup);
+ return BCM_ERR_NOMEM;
+ }
+ for (prty = 0; prty < qgroup->parm.nqueues; prty++)
+ {
+ STAILQ_INIT(&qgroup->msgl[prty]);
+ }
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (qgroup->parm.name)
+ {
+ strncpy(qgroup->name, qgroup->parm.name, sizeof(qgroup->parm.name) - 1);
+ qgroup->parm.name = qgroup->name;
+ }
+ qgroup->magic = BCMOS_MSG_QGROUP_VALID;
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&msg_qgroup_list, qgroup, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+
+ return BCM_ERR_OK;
+}
+
+/** Destroy queue group
+ *
+ * \param[in] qgroup Queue group handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_qgroup_destroy(bcmos_msg_qgroup *qgroup)
+{
+ bcmos_qgroup_prty prty;
+
+ if (!qgroup || qgroup->magic != BCMOS_MSG_QGROUP_VALID)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "queue group handle is invalid\n");
+ }
+
+ qgroup->magic = BCMOS_MSG_QGROUP_DELETED;
+
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&msg_qgroup_list, qgroup, bcmos_msg_qgroup, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+
+ bcmos_sem_destroy(&qgroup->m);
+
+ /* Release all pending messages */
+ if (qgroup->msgl)
+ {
+ for (prty = 0; prty < qgroup->parm.nqueues; prty++)
+ {
+ bcmos_msg_list_destroy(&qgroup->msgl[prty]);
+ }
+ bcmos_free(qgroup->msgl);
+ }
+ return BCM_ERR_OK;
+
+}
+
+/** Get queue group info */
+bcmos_errno bcmos_msg_qgroup_query(const bcmos_msg_qgroup *qgroup, bcmos_msg_qgroup_info *info)
+{
+ if (!qgroup || !info)
+ return BCM_ERR_PARM;
+
+ info->parm = qgroup->parm;
+ info->stat = qgroup->stat;
+
+ return BCM_ERR_OK;
+}
+
+/** Message queue group iterator
+ * \param[in] prev Previous queue group. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_msg_qgroup_get_next(const bcmos_msg_qgroup **prev)
+{
+ const bcmos_msg_qgroup *qgrp;
+
+ if (prev == NULL)
+ {
+ return BCM_ERR_PARM;
+ }
+ qgrp = *prev;
+ if (qgrp && qgrp->magic != BCMOS_MSG_QGROUP_VALID)
+ {
+ return BCM_ERR_PARM;
+ }
+ if (qgrp)
+ {
+ qgrp = STAILQ_NEXT(qgrp, list);
+ }
+ else
+ {
+ qgrp = STAILQ_FIRST(&msg_qgroup_list);
+ }
+ *prev = qgrp;
+ if (!qgrp)
+ {
+ return BCM_ERR_NO_MORE;
+ }
+ return BCM_ERR_OK;
+}
+
+/* get message from non-empty queue group queue */
+static inline bcmos_msg *_bcmos_qgroup_msg_get(bcmos_msg_qgroup *qgroup, bcmos_qgroup_prty prty)
+{
+ bcmos_msg *msg;
+ msg = STAILQ_FIRST(&qgroup->msgl[prty]);
+ BUG_ON(!msg);
+ STAILQ_REMOVE_HEAD(&qgroup->msgl[prty], next);
+ if (STAILQ_EMPTY(&qgroup->msgl[prty]))
+ {
+ qgroup->active_mask &= ~(1 << prty);
+ }
+ return msg;
+}
+
+/* Send message to queue group */
+bcmos_errno bcmos_msg_send_to_qgroup(bcmos_msg_qgroup *qgroup, bcmos_msg *msg, bcmos_qgroup_prty prty,
+ bcmos_msg_send_flags flags)
+{
+ long lock_flags;
+ bcmos_errno rc = BCM_ERR_OK;
+
+ if (prty >= qgroup->parm.nqueues)
+ {
+ if (!(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ {
+ bcmos_msg_free(msg);
+ }
+ return BCM_ERR_PARM;
+ }
+ msg->send_flags = flags;
+
+ lock_flags = bcmos_fastlock_lock(&qgroup->lock);
+
+ /* Put into the relevant queue */
+ STAILQ_INSERT_TAIL(&qgroup->msgl[prty], msg, next);
+ qgroup->active_mask |= (1 << prty);
+ _bcmos_qgroup_stat_inc(qgroup);
+
+ /* Overflow check */
+ if ((qgroup->stat.msg_in > qgroup->parm.size))
+ {
+ bcmos_msg *m;
+ bcmos_qgroup_prty i;
+ /* Find the lowest-priority queue with data and discard the head message.
+ * The loop always finds something because we've just added a message
+ */
+ for (i = qgroup->parm.nqueues - 1; (qgroup->active_mask & (1 << i)) == 0; i--)
+ ;
+ m = _bcmos_qgroup_msg_get(qgroup, i);
+ --qgroup->stat.msg_in;
+ ++qgroup->stat.msg_discarded;
+ if (!(m->send_flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ {
+ bcmos_msg_free(m);
+ }
+ rc = BCM_ERR_OVERFLOW;
+ }
+
+ /* Kick waiting task */
+ if (qgroup->is_waiting)
+ {
+ qgroup->is_waiting = BCMOS_FALSE;
+ bcmos_fastlock_unlock(&qgroup->lock, lock_flags);
+ bcmos_sem_post(&qgroup->m);
+ }
+ else
+ {
+ bcmos_fastlock_unlock(&qgroup->lock, lock_flags);
+ }
+
+ return rc;
+
+}
+
+/* Get highest priority message from queue group */
+bcmos_errno bcmos_msg_recv_from_qgroup(bcmos_msg_qgroup *qgroup, uint32_t timeout, bcmos_msg **msg)
+{
+ long lock_flags;
+ bcmos_qgroup_prty prty;
+
+ if (!qgroup || !msg)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "qgroup %p, msg %p\n", qgroup, msg);
+
+ lock_flags = bcmos_fastlock_lock(&qgroup->lock);
+ if (!qgroup->active_mask)
+ {
+ if (!timeout)
+ {
+ bcmos_fastlock_unlock(&qgroup->lock, lock_flags);
+ return BCM_ERR_NOENT;
+ }
+
+ /* Receive with wait */
+ qgroup->is_waiting = BCMOS_TRUE;
+ bcmos_fastlock_unlock(&qgroup->lock, lock_flags);
+
+ /* wait for it */
+ bcmos_sem_wait(&qgroup->m, timeout);
+
+ /* Done waiting. Either got a message or a timeout */
+ lock_flags = bcmos_fastlock_lock(&qgroup->lock);
+ qgroup->is_waiting = BCMOS_FALSE;
+ if (!qgroup->active_mask)
+ {
+ bcmos_fastlock_unlock(&qgroup->lock, lock_flags);
+ return BCM_ERR_TIMEOUT;
+ }
+ }
+
+ prty = (bcmos_qgroup_prty)(ffs(qgroup->active_mask) - 1);
+ BUG_ON(prty >= qgroup->parm.nqueues);
+ *msg = _bcmos_qgroup_msg_get(qgroup, prty);
+ _bcmos_qgroup_stat_dec(qgroup);
+ bcmos_fastlock_unlock(&qgroup->lock, lock_flags);
+
+ return BCM_ERR_OK;
+}
+
+
+/*
+ * Message registration and dispatch
+ */
+
+/* Hash entry */
+typedef struct msg_hash_entry msg_hash_entry;
+
+struct msg_hash_entry
+{
+ /* Key */
+ uint32_t key; /* msg_type + instance */
+
+ /* Value */
+ bcmos_module_id module_id;
+ F_bcmos_msg_handler handler;
+
+ /* List of entries with the same key */
+ SLIST_ENTRY(msg_hash_entry) list;
+};
+
+/* Hash table */
+static SLIST_HEAD(msg_hash, msg_hash_entry) msg_hash_table[BCMOS_MSG_HASH_SIZE];
+
+/* Make hash key from msg_type and instance */
+static inline uint32_t _bcmos_msg_hash_key(bcmos_msg_id msg_type, bcmos_msg_instance instance)
+{
+ return ((uint32_t)instance << 16) | (uint32_t)msg_type;
+}
+
+/* Hash function */
+static inline uint32_t _bcmos_msg_hash_func(uint32_t key)
+{
+ key ^= (key >> 9);
+ key ^= (key << 3);
+ key ^= (key >> 15);
+ return key % BCMOS_MSG_HASH_SIZE;
+}
+
+/* Find entry in hash */
+static inline msg_hash_entry *_bcmos_msg_hash_find(bcmos_msg_id msg_type, bcmos_msg_instance instance)
+{
+ uint32_t key = _bcmos_msg_hash_key(msg_type, instance);
+ uint32_t hash = _bcmos_msg_hash_func(key);
+ msg_hash_entry *entry;
+ SLIST_FOREACH(entry, &msg_hash_table[hash], list)
+ {
+ if (entry->key == key)
+ break;
+ }
+ return entry;
+}
+
+/* Register message_type+instance --> module+handler */
+bcmos_errno bcmos_msg_register(bcmos_msg_id msg_type, bcmos_msg_instance instance,
+ bcmos_module_id module_id, F_bcmos_msg_handler handler)
+{
+ uint32_t key = _bcmos_msg_hash_key(msg_type, instance);
+ uint32_t hash = _bcmos_msg_hash_func(key);
+ msg_hash_entry *entry;
+ long lock_flags;
+
+ if (!handler)
+ return BCM_ERR_PARM;
+
+ entry = bcmos_calloc(sizeof(*entry));
+ if (!entry)
+ return BCM_ERR_NOMEM;
+
+ entry->key = key;
+ entry->module_id = module_id;
+ entry->handler = handler;
+ lock_flags = bcmos_fastlock_lock(&bcmos_msg_register_lock);
+ if (_bcmos_msg_hash_find(msg_type, instance) != NULL)
+ {
+ bcmos_fastlock_unlock(&bcmos_msg_register_lock, lock_flags);
+ bcmos_free(entry);
+ return BCM_ERR_ALREADY;
+ }
+ SLIST_INSERT_HEAD(&msg_hash_table[hash], entry, list);
+ bcmos_fastlock_unlock(&bcmos_msg_register_lock, lock_flags);
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcmos_msg_unregister(bcmos_msg_id msg_type, bcmos_msg_instance instance, bcmos_module_id module_id)
+{
+ uint32_t key = _bcmos_msg_hash_key(msg_type, instance);
+ uint32_t hash = _bcmos_msg_hash_func(key);
+ msg_hash_entry *entry;
+ long lock_flags;
+
+ lock_flags = bcmos_fastlock_lock(&bcmos_msg_register_lock);
+ entry = _bcmos_msg_hash_find(msg_type, instance);
+ if (!entry)
+ {
+ bcmos_fastlock_unlock(&bcmos_msg_register_lock, lock_flags);
+ return BCM_ERR_NOENT;
+ }
+
+ if (entry->module_id != module_id)
+ {
+ bcmos_fastlock_unlock(&bcmos_msg_register_lock, lock_flags);
+ return BCM_ERR_INVALID_OP;
+ }
+
+ SLIST_REMOVE(&msg_hash_table[hash], entry, msg_hash_entry, list);
+ bcmos_fastlock_unlock(&bcmos_msg_register_lock, lock_flags);
+ bcmos_free(entry);
+
+ return BCM_ERR_OK;
+}
+
+void bcmos_msg_shutdown_mode_set(bcmos_bool shutdown_mode)
+{
+ bcmos_msg_shutdown_mode = shutdown_mode;
+}
+
+bcmos_bool bcmos_msg_shutdown_mode_get(void)
+{
+ return bcmos_msg_shutdown_mode;
+}
+
+/* Dispatch message to registered module */
+bcmos_errno bcmos_msg_dispatch(bcmos_msg *msg, bcmos_msg_send_flags flags)
+{
+ bcmos_errno err;
+
+ if (unlikely(bcmos_msg_shutdown_mode))
+ {
+ /* In shutdown mode, we need to acquire the same lock used to protect bcmos_msg_register() /
+ * bcmos_msg_unregister(), since we must support calling these functions concurrently. */
+ msg_hash_entry *entry;
+ bcmos_sem *sem_to_post = NULL;
+ long lock_flags = bcmos_fastlock_lock(&bcmos_msg_register_lock);
+ entry = _bcmos_msg_hash_find(msg->type, msg->instance);
+
+ if (entry)
+ {
+ msg->handler = entry->handler;
+ err = _bcmos_msg_send_to_module(entry->module_id, msg, flags, &sem_to_post);
+ }
+ else
+ {
+ /* Not found. Release automatically if requested. */
+ if (!(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ bcmos_msg_free(msg);
+ err = BCM_ERR_OK;
+ }
+
+ bcmos_fastlock_unlock(&bcmos_msg_register_lock, lock_flags);
+ if (sem_to_post)
+ bcmos_sem_post(sem_to_post);
+ }
+ else
+ {
+ msg_hash_entry *entry = _bcmos_msg_hash_find(msg->type, msg->instance);
+
+ if (entry)
+ {
+ msg->handler = entry->handler;
+ err = bcmos_msg_send_to_module(entry->module_id, msg, flags);
+ }
+ else
+ {
+ /* Not found. Release automatically if requested. */
+ BCMOS_TRACE_ERR("Can't dispatch unregistered msg %d:%d\n", msg->type, msg->instance);
+ if (!(flags & BCMOS_MSG_SEND_NO_FREE_ON_ERROR))
+ bcmos_msg_free(msg);
+ err = BCM_ERR_NOENT;
+ }
+ }
+
+ return err;
+}
+
+/*
+ * Task management
+ */
+
+/*
+ * Default task handler
+ */
+/*lint -e{632,633,634}
+ * There are a few warnings about
+ * implicit bcmos_errno conversion to int. It is to bothersome now
+ * to change task handler prototype everywhere and the warning is harmless
+ */
+int bcmos_dft_task_handler(long data)
+{
+ bcmos_task *task = (bcmos_task *)data;
+ long flags = 0, q_flags = 0;
+ uint32_t active_modules;
+ int last_module = 0; /* 1-based last handled module index */
+ bcmos_module *module;
+ bcmos_msg *msg;
+ int rc;
+
+
+ /* Set / validate task timeout */
+ rc = bcmos_task_timeout_set(task, task->parm.msg_wait_timeout, task->parm.timeout_handler);
+ if (rc)
+ {
+ return rc;
+ }
+
+ /* Call init callback if any */
+ if (task->parm.init_handler)
+ {
+ rc = task->parm.init_handler(task->parm.data);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Task %s: init_handler returned error %s (%d)\n",
+ task->parm.name, bcmos_strerror((bcmos_errno)rc), rc);
+ bcmos_task_destroy(task);
+ return rc;
+ }
+ }
+
+ /* Wait for module activity */
+ while (!task->destroy_request)
+ {
+ task->current_module = BCMOS_MODULE_ID_NONE;
+
+ /* Wait for module activity */
+ rc = bcmos_sem_wait(&task->active_sem, task->parm.msg_wait_timeout);
+ if (rc == BCM_ERR_TIMEOUT)
+ {
+ F_bcmos_task_handler timeout_handler = task->parm.timeout_handler;
+
+ /* Handle possible race condition */
+ if (!timeout_handler)
+ continue;
+ rc = timeout_handler(data);
+ if (rc != BCM_ERR_OK)
+ {
+ BCMOS_TRACE_ERR("Task %s: terminated by timeout_handler. error %s (%d)\n",
+ task->parm.name, bcmos_strerror(rc), rc);
+ break;
+ }
+ /* Keep waiting */
+ continue;
+ }
+
+ /* RR active modules */
+ do
+ {
+ flags = bcmos_fastlock_lock(&task->active_lock);
+ active_modules = (task->active_modules >> last_module);
+ if (!active_modules)
+ {
+ last_module = 0;
+ active_modules = task->active_modules;
+ if (!active_modules)
+ {
+ /* No modules with work to do */
+ bcmos_fastlock_unlock(&task->active_lock, flags);
+ continue;
+ }
+ }
+ last_module += ffs(active_modules);
+ BUG_ON(last_module > BCMOS_MAX_MODULES_PER_TASK);
+ module = task->modules[last_module - 1];
+ BUG_ON(!module);
+
+ q_flags = bcmos_fastlock_lock(&module->msgq.lock);
+ /* Get message from the module's message queue */
+ msg = _bcmos_msg_get(&module->msgq);
+ if (!msg)
+ {
+ bcmos_fastlock_unlock(&module->msgq.lock, q_flags);
+ task->active_modules &= ~(1 << (last_module - 1));
+ bcmos_fastlock_unlock(&task->active_lock, flags);
+ continue;
+ }
+
+ bcmos_fastlock_unlock(&module->msgq.lock, q_flags);
+ bcmos_fastlock_unlock(&task->active_lock, flags);
+
+ /* Handle the message */
+ if (msg->handler)
+ {
+ task->current_module = module->id;
+ msg->handler(module->id, msg);
+ }
+ else
+ {
+ BCMOS_TRACE_ERR("msg->handler is not set. msg->type=%d\n", msg->type);
+ bcmos_msg_free(msg);
+ }
+
+ } while (task->active_modules);
+ }
+
+ return 0;
+}
+
+/* Set task message timeout.
+ * The function is only supported in integration mode
+ */
+bcmos_errno bcmos_task_timeout_set(bcmos_task *task, uint32_t timeout, F_bcmos_task_handler timeout_handler)
+{
+ if (task->parm.handler)
+ {
+ BCMOS_TRACE_ERR("%s: The function is only supported in integration mode (task handler == NULL)\n", task->parm.name);
+ return BCM_ERR_NOT_SUPPORTED;
+ }
+ if ((timeout && timeout != BCMOS_WAIT_FOREVER) && !timeout_handler)
+ {
+ BCMOS_TRACE_ERR("%s: timeout_handler is not set\n", task->parm.name);
+ return BCM_ERR_PARM;
+ }
+
+ /* 0 means FOREVER here */
+ if (!timeout)
+ timeout = BCMOS_WAIT_FOREVER;
+
+ task->parm.timeout_handler = timeout_handler;
+ task->parm.msg_wait_timeout = timeout;
+
+ return BCM_ERR_OK;
+}
+
+/*
+ * Module
+ */
+
+/* Register module */
+bcmos_errno bcmos_module_create(bcmos_module_id module_id, bcmos_task *task, bcmos_module_parm *parm)
+{
+ bcmos_module *module;
+ bcmos_errno rc = BCM_ERR_OK;
+ int i;
+
+ if ((unsigned)module_id >= (unsigned)BCMOS_MODULE_ID__NUM_OF || !parm)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "module %d, parm %p\n", module_id, parm);
+ if (!task)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOT_SUPPORTED, "No task\n");
+ if (bcmos_modules[module_id])
+ BCMOS_TRACE_RETURN(BCM_ERR_ALREADY, "module_id %d\n", module_id);
+
+ module = bcmos_calloc(sizeof(bcmos_module));
+ if (!module)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "module_id %d\n", module_id);
+ module->id = module_id;
+ module->my_task = task;
+ module->parm = *parm;
+ module->context = (void *)parm->data;
+ bcmos_msg_queue_nw_init(&module->msgq, &parm->qparm);
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (module->parm.qparm.name)
+ {
+ strncpy(module->name, module->parm.qparm.name, sizeof(module->name) - 1);
+ module->parm.qparm.name = module->name;
+ }
+
+ /* Assign module id */
+ for (i = 0; i < BCMOS_MAX_MODULES_PER_TASK; i++)
+ {
+ if (!task->modules[i])
+ {
+ task->modules[i] = module;
+ module->idx = i;
+ break;
+ }
+ }
+ if (i == BCMOS_MAX_MODULES_PER_TASK)
+ {
+ bcmos_free(module);
+ BCMOS_TRACE_RETURN(BCM_ERR_TOO_MANY, "module_id %d\n", module_id);
+ }
+
+ bcmos_modules[module_id] = module;
+
+ /* Init module */
+ if (parm->init)
+ {
+ rc = parm->init(parm->data);
+ if (rc)
+ bcmos_module_destroy(module_id);
+ }
+
+ return rc;
+}
+
+/* Un-register module */
+bcmos_errno bcmos_module_destroy(bcmos_module_id module_id)
+{
+ bcmos_module *module = _bcmos_module_get(module_id);
+ bcmos_task *task;
+ long lock_flags, q_lock_flags;
+ bcmos_msg_list msgl_urg, msgl;
+
+ if (!module)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOENT, "module_id %d\n", module_id);
+
+ task = module->my_task;
+ lock_flags = bcmos_fastlock_lock(&task->active_lock);
+ task->modules[module->idx] = NULL;
+ task->active_modules &= ~(1 << module->idx);
+
+ /* Because we are not allowed to free memory (via bcmos_free()) when interrupts are locked, we only empty the linked list (via SLIST_INIT()) and the free comes outside the locked
+ * section. */
+ q_lock_flags = bcmos_fastlock_lock(&module->msgq.lock);
+ msgl_urg = module->msgq.msgl_urg;
+ msgl = module->msgq.msgl;
+ STAILQ_INIT(&module->msgq.msgl_urg);
+ STAILQ_INIT(&module->msgq.msgl);
+ bcmos_fastlock_unlock(&module->msgq.lock, q_lock_flags);
+ bcmos_fastlock_unlock(&task->active_lock, lock_flags);
+
+ bcmos_msg_list_destroy(&msgl_urg);
+ bcmos_msg_list_destroy(&msgl);
+
+ if (module->parm.exit)
+ module->parm.exit(module->parm.data);
+ bcmos_modules[module_id] = NULL;
+ bcmos_free(module);
+
+ return BCM_ERR_OK;
+}
+
+/* Get current module id in the current task */
+bcmos_module_id bcmos_module_current(void)
+{
+ bcmos_task *task = bcmos_task_current();
+
+ if (!task)
+ return BCMOS_MODULE_ID_NONE;
+ return task->current_module;
+}
+
+/* Get module context set by bcmos_module_context_set() */
+void *bcmos_module_context(bcmos_module_id module_id)
+{
+ bcmos_module *module = _bcmos_module_get(module_id);
+ if (!module)
+ return NULL;
+ return module->context;
+}
+
+/* Set module context */
+bcmos_errno bcmos_module_context_set(bcmos_module_id module_id, void *context)
+{
+ bcmos_module *module = _bcmos_module_get(module_id);
+
+ if (!module)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOENT, "module_id %d\n", module_id);
+ module->context = context;
+ return BCM_ERR_OK;
+}
+
+/* Query module info */
+bcmos_errno bcmos_module_query(bcmos_module_id module_id, const bcmos_task **task, bcmos_msg_queue_info *info)
+{
+ bcmos_module *module = _bcmos_module_get(module_id);
+
+ if (!module)
+ {
+ return BCM_ERR_NOENT;
+ }
+ if (task)
+ {
+ *task = module->my_task;
+ }
+ if (info)
+ {
+ info->parm = module->parm.qparm;
+ info->stat = module->msgq.stat;
+ }
+ return BCM_ERR_OK;
+}
+
+/*
+ * Events
+ */
+
+/* This function handles event arrival in module context */
+static void _bcmos_ev_in_module_handler(bcmos_module_id module_id, bcmos_msg *msg)
+{
+ bcmos_event *ev = _bcmos_msg_to_event(msg);
+ uint32_t active_bits;
+ long lock_flags;
+
+ active_bits = ev->active_bits & ev->parm.mask;
+ ev->parm.handler(ev->id, active_bits);
+
+ lock_flags = bcmos_fastlock_lock(&ev->lock);
+ ev->active_bits &= ~active_bits;
+ ev->is_waiting = BCMOS_TRUE;
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+}
+
+/* Release event message. Only called in exceptional situations,
+ * such as module queue destroy. Do nothing.
+ */
+static void _bcmos_ev_msg_release(bcmos_msg *msg)
+{
+}
+
+/* Create event set */
+bcmos_errno bcmos_event_create(bcmos_event_id event_id, bcmos_event_parm *parm)
+{
+ bcmos_event *ev;
+ bcmos_module *module = NULL;
+ bcmos_errno rc;
+
+ if ((unsigned)event_id >= (unsigned)BCMOS_EVENT_ID__NUM_OF)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "event_id %d\n", event_id);
+
+ if (_bcmos_event_get(event_id))
+ BCMOS_TRACE_RETURN(BCM_ERR_ALREADY, "event_id %d\n", event_id);
+
+ if (parm && parm->module_id != BCMOS_MODULE_ID_NONE)
+ {
+ module = _bcmos_module_get(parm->module_id);
+ if (!module)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOENT, "module_id %d\n", parm->module_id);
+ if (!parm->handler || !parm->mask)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "event_id %d, handler %p, mask %x\n", event_id, parm->handler, parm->mask);
+ }
+
+ ev = bcmos_calloc(sizeof(bcmos_event));
+ if (!ev)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "event_id %d\n", event_id);
+
+ ev->id = event_id;
+ if (parm)
+ ev->parm = *parm;
+ bcmos_fastlock_init(&ev->lock, ev->parm.flags);
+ {
+ rc = bcmos_sem_create(&ev->m, 0, ev->parm.flags, ev->parm.name);
+ if (rc)
+ {
+ bcmos_free(ev);
+ return rc;
+ }
+ }
+
+ /* Initialize event message in integration mode */
+ if (ev->parm.module_id != BCMOS_MODULE_ID_NONE)
+ {
+ ev->msg.handler = _bcmos_ev_in_module_handler;
+ ev->msg.release = _bcmos_ev_msg_release;
+ ev->msg.sender = BCMOS_MODULE_ID_NONE;
+ ev->msg.type = BCMOS_MSG_ID_INTERNAL_EVENT;
+ ev->is_waiting = BCMOS_TRUE;
+ }
+
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (ev->parm.name)
+ {
+ strncpy(ev->name, ev->parm.name, sizeof(ev->name) - 1);
+ ev->parm.name = ev->name;
+ }
+
+ bcmos_events[event_id] = ev;
+
+ return BCM_ERR_OK;
+}
+
+/* Destroy event set created by bcmos_event_create() */
+bcmos_errno bcmos_event_destroy(bcmos_event_id event_id)
+{
+ return BCM_ERR_NOT_SUPPORTED;
+}
+
+/* Raise event */
+bcmos_errno bcmos_event_raise(bcmos_event_id event_id, uint32_t active_bits)
+{
+ bcmos_event *ev = _bcmos_event_get(event_id);
+ long lock_flags;
+
+ if (!ev)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOENT, "event_id %d\n", event_id);
+
+ lock_flags = bcmos_fastlock_lock(&ev->lock);
+ ev->active_bits |= active_bits;
+ if (ev->is_waiting && (ev->active_bits & ev->parm.mask))
+ {
+ ev->is_waiting = BCMOS_FALSE;
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+ if (ev->parm.module_id != BCMOS_MODULE_ID_NONE)
+ bcmos_msg_send_to_module(ev->parm.module_id, &ev->msg, BCMOS_MSG_SEND_URGENT | BCMOS_MSG_SEND_NOLIMIT);
+ else
+ bcmos_sem_post(&ev->m);
+ }
+ else
+ {
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+ }
+
+ return BCM_ERR_OK;
+}
+
+/* Wait for event */
+bcmos_errno bcmos_event_recv(bcmos_event_id event_id, uint32_t mask,
+ uint32_t timeout, uint32_t *active_bits)
+{
+ bcmos_event *ev = _bcmos_event_get(event_id);
+ long lock_flags;
+
+ BUG_ON(!active_bits);
+ if (!ev)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOENT, "event_id %d is not registered\n", event_id);
+
+ lock_flags = bcmos_fastlock_lock(&ev->lock);
+ *active_bits = ev->active_bits & mask;
+ if (*active_bits)
+ {
+ ev->active_bits &= ~ *active_bits;
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+ return BCM_ERR_OK;
+ }
+ if (!timeout)
+ {
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+ return BCM_ERR_NOENT;
+ }
+
+ /* recv with wait */
+ ev->is_waiting = BCMOS_TRUE;
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+
+ /* wait for it */
+ bcmos_sem_wait(&ev->m, timeout);
+ /* Either got event or timeout */
+ lock_flags = bcmos_fastlock_lock(&ev->lock);
+ *active_bits = ev->active_bits & mask;
+ ev->active_bits &= ~ *active_bits;
+ ev->is_waiting = BCMOS_FALSE;
+ bcmos_fastlock_unlock(&ev->lock, lock_flags);
+ /* If we wait forever and we got an event that does not match the mask we wait on (this is the only possible reason getting here if waiting forever), then we
+ * want to avoid returning BCM_ERR_TIMEOUT - it's not an error. */
+ if (timeout != BCMOS_WAIT_FOREVER && !*active_bits)
+ return BCM_ERR_TIMEOUT;
+ return BCM_ERR_OK;
+}
+
+/*
+ * Timer
+ */
+
+/* compare timestamps minding wrap-around
+ * returns delta >= 0 if ts1 >= ts2
+ */
+static inline int32_t _bcmos_timer_ts_delta(uint32_t ts1, uint32_t ts2)
+{
+ int32_t delta = (int)(ts1 - ts2);
+ return delta;
+}
+
+static int32_t _bcmos_timer_compare(struct bcmos_timer *t1, struct bcmos_timer *t2)
+{
+ int32_t delta = _bcmos_timer_ts_delta(t1->expire_at, t2->expire_at);
+#if defined(BCMOS_TIMER_RB_TREE) && !defined(BCMOS_TIMER_RB_TREE_LIST)
+ /* FreeBSD RB tree implementation doesn't support 2 nodes with the same key */
+ if (!delta)
+ delta = 1;
+#endif
+ return delta;
+}
+
+static inline void _bcmos_start_system_timer(bcmos_timer *head)
+{
+ if (head)
+ {
+ int32_t delay = _bcmos_timer_ts_delta(head->expire_at, bcmos_timestamp());
+ /* Handle rare race condition when next timer expired while we were fiddling
+ * with the pool. Just give it 1 more "tick". System handler handles all timers
+ * expired (<now .. now + PRECISION/2)
+ */
+ if (delay <= 0)
+ {
+ delay = BCMOS_TIMER_PRECISION_US / 2;
+ }
+ bcmos_sys_timer_start(&tmr_pool.sys_timer, delay);
+ }
+ else
+ {
+ bcmos_sys_timer_stop(&tmr_pool.sys_timer);
+ }
+}
+
+/*
+ * Timer pool: RB tree or TAILQ-based implementation
+ */
+static void _bcmos_timer_pool_insert(bcmos_timer *timer, uint32_t delay, bcmos_bool start_sys_timer)
+{
+ long flags;
+ bcmos_timer *head;
+
+ flags = bcmos_fastlock_lock(&tmr_pool.lock);
+ if (BCMOS_TIMER_IS_RUNNING(timer))
+ {
+ bcmos_fastlock_unlock(&tmr_pool.lock, flags);
+ return;
+ }
+ timer->period = timer->parm.periodic ? delay : 0;
+ timer->expire_at = BCMOS_ROUND_UP(bcmos_timestamp() + delay, BCMOS_TIMER_PRECISION_US / 2);
+ TMR_POOL_INSERT(&tmr_pool, timer);
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+ timer->flags |= BCMOS_TIMER_FLAG_RUNNING;
+
+ /* If new timer is at the top - kick system timer */
+ if (start_sys_timer)
+ {
+ head = TMR_POOL_FIRST(&tmr_pool);
+ if (timer == head)
+ {
+ _bcmos_start_system_timer(head);
+ }
+ }
+ bcmos_fastlock_unlock(&tmr_pool.lock, flags);
+}
+
+static void _bcmos_timer_stop(bcmos_timer *timer)
+{
+ long flags;
+ bcmos_bool was_top;
+ bcmos_msg_queue_nw *queue;
+
+ /* First take running timer out of the active pool */
+ flags = bcmos_fastlock_lock(&tmr_pool.lock);
+ timer->period = 0; /* Prevent periodic timer restart */
+ if (BCMOS_TIMER_IS_RUNNING(timer))
+ {
+ timer->flags &= ~BCMOS_TIMER_FLAG_RUNNING;
+ was_top = (timer == TMR_POOL_FIRST(&tmr_pool));
+ TMR_POOL_REMOVE(&tmr_pool, timer);
+
+ /* If timer was the top - stop/restart system timer */
+ if (was_top)
+ {
+ _bcmos_start_system_timer(TMR_POOL_FIRST(&tmr_pool));
+ }
+ }
+ bcmos_fastlock_unlock(&tmr_pool.lock, flags);
+
+ /* Now timer is not in the active pool. Perhaps it is already in
+ * destination module's queue. Take it out if yes.
+ */
+ queue = timer->queue;
+ if (queue)
+ {
+ flags = bcmos_fastlock_lock(&queue->lock);
+ /* Check queue again because the previous check was unprotected */
+ if (timer->queue)
+ {
+ bcmos_msg_list *msg_list = ((timer->parm.flags & BCMOS_TIMER_PARM_FLAGS_NON_URGENT))
+ ? &queue->msgl : &queue->msgl_urg;
+ if (STAILQ_REMOVE_SAFE(msg_list, &timer->msg, bcmos_msg, next) != NULL)
+ {
+ _bcmos_msgq_stat_dec(queue);
+ }
+ timer->queue = NULL;
+ }
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+ bcmos_fastlock_unlock(&queue->lock, flags);
+ }
+
+ /* If timer has already expired and we weren't able to stop it -
+ * wait for expiration callback to finish before leaving _bcmos_timer_stop()
+ */
+ if (BCMOS_TIMER_IS_EXPIRED(timer))
+ {
+ bcmos_task *t = bcmos_task_current();
+
+ /* Skip wait if timer is being stopped / restarted from inside the handler */
+ if (t != timer->task)
+ {
+ while (BCMOS_TIMER_IS_EXPIRED(timer) && BCMOS_TIMER_IS_VALID(timer))
+ {
+ bcmos_usleep(1000);
+ }
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+ }
+ }
+}
+
+
+/* System timer expiration handler.
+ * Execute all timers that expired and restart system timer
+ */
+static void _sys_timer_handler(void *data)
+{
+ bcmos_timer_pool *pool = (bcmos_timer_pool *)data;
+ bcmos_timer *timer;
+ bcmos_timer_rc rc;
+ long flags;
+
+ BUG_ON(pool != &tmr_pool);
+ flags = bcmos_fastlock_lock(&pool->lock);
+ while ((timer=TMR_POOL_FIRST(pool)) != NULL)
+ {
+ /* Stop when reached timer that hasn't expired yet */
+ if (_bcmos_timer_ts_delta(timer->expire_at, bcmos_timestamp()) > BCMOS_TIMER_PRECISION_US / 2)
+ break;
+ timer->flags |= BCMOS_TIMER_FLAG_EXPIRED;
+ timer->flags &= ~BCMOS_TIMER_FLAG_RUNNING;
+ /* IT: Barrier here ? */
+ TMR_POOL_REMOVE(pool, timer);
+
+ /* Execute handler. Unlock first and re-lock in the end
+ * It is safe to unlock here because the top loop starts from MIN every time
+ */
+ bcmos_fastlock_unlock(&pool->lock, flags);
+ rc = timer->handler(timer, timer->parm.data);
+ if (!timer->parm.owner)
+ {
+ if (rc == BCMOS_TIMER_OK && timer->period)
+ {
+ uint32_t interval = timer->period;
+ timer->period = 0;
+ _bcmos_timer_pool_insert(timer, interval, BCMOS_FALSE);
+ }
+ else
+ {
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+ }
+ }
+ flags = bcmos_fastlock_lock(&pool->lock);
+ }
+ /* Finally kick system timer */
+ _bcmos_start_system_timer(timer);
+ bcmos_fastlock_unlock(&pool->lock, flags);
+}
+
+/* Send timer expiration to the target module as urgent message.
+ * _bcmos_timer_in_module_handler() will get called in the module context
+ */
+static bcmos_timer_rc _bcmos_timer_send_to_module_handler(bcmos_timer *timer, long data)
+{
+ bcmos_errno rc;
+ bcmos_module *module = _bcmos_module_get(timer->parm.owner);
+ bcmos_msg_send_flags send_flags;
+ if (!module)
+ {
+ /* Shouldn't happen, unless the module was destroyed */
+ BCMOS_TRACE_ERR("_bcmos_timer_send_to_module_handler() -- no module=%u (timer->parm.handler=0x%p)\n", timer->parm.owner, timer->parm.handler);
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+ return BCMOS_TIMER_STOP; /* will restart in module context if necessary */
+ }
+ timer->queue = &module->msgq;
+ send_flags = BCMOS_MSG_SEND_NOLIMIT;
+ if (!((timer->parm.flags & BCMOS_TIMER_PARM_FLAGS_NON_URGENT)))
+ send_flags |= BCMOS_MSG_SEND_URGENT;
+ rc = bcmos_msg_send_to_module(timer->parm.owner, &timer->msg, send_flags);
+ if (rc)
+ {
+ /* Shouldn't happen, unless the module was destroyed. Very short race condition here */
+ timer->queue = NULL;
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+ BCMOS_TRACE_ERR("_bcmos_timer_send_to_module_handler() --> %d\n", rc);
+ }
+ return BCMOS_TIMER_STOP; /* will restart in module context if necessary */
+}
+
+/* This function handles timer expiration in module context */
+static void _bcmos_timer_in_module_handler(bcmos_module_id module_id, bcmos_msg *msg)
+{
+ bcmos_timer *timer = _bcmos_msg_to_timer(msg);
+ bcmos_module *module = _bcmos_module_get(timer->parm.owner);
+ bcmos_timer_rc rc;
+
+ /* Call timer's callback function and restart the timer if necessary */
+ timer->queue = NULL;
+ /* module can't be NULL here. it is checked anyway to keep static code analyzer happy */
+ timer->task = module ? module->my_task : (bcmos_task*)NULL;
+ rc = timer->parm.handler(timer, timer->parm.data);
+ timer->task = NULL;
+ if (rc == BCMOS_TIMER_OK && timer->period)
+ _bcmos_timer_pool_insert(timer, timer->period, BCMOS_TRUE);
+ else
+ timer->flags &= ~BCMOS_TIMER_FLAG_EXPIRED;
+}
+
+/* Release timer message. Only called in exceptional situations,
+ * such as module queue destroy. Do nothing
+ */
+static void _bcmos_timer_msg_release(bcmos_msg *msg)
+{
+}
+
+/* Create timer */
+bcmos_errno bcmos_timer_create(bcmos_timer *timer, bcmos_timer_parm *parm)
+{
+ if (!timer || !parm || !parm->handler)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "timer %p, parm %p handler %p\n", timer, parm, parm ? parm->handler : NULL);
+ if (parm->owner != BCMOS_MODULE_ID_NONE && _bcmos_module_get(parm->owner) == NULL)
+ BCMOS_TRACE_RETURN(BCM_ERR_NOENT, "module_id %d\n", parm->owner);
+ memset(timer, 0, sizeof(bcmos_timer));
+ timer->parm = *parm;
+ if (parm->owner == BCMOS_MODULE_ID_NONE)
+ timer->handler = parm->handler;
+ else
+ {
+ timer->handler = _bcmos_timer_send_to_module_handler;
+ timer->msg.handler = _bcmos_timer_in_module_handler;
+ timer->msg.release = _bcmos_timer_msg_release;
+ timer->msg.sender = BCMOS_MODULE_ID_NONE;
+ timer->msg.type = BCMOS_MSG_ID_INTERNAL_TIMER;
+ }
+ timer->flags |= BCMOS_TIMER_FLAG_VALID;
+ return BCM_ERR_OK;
+}
+
+/* Destroy timer */
+void bcmos_timer_destroy(bcmos_timer *timer)
+{
+ BUG_ON(!timer);
+ bcmos_timer_stop(timer);
+ timer->flags &= ~BCMOS_TIMER_FLAG_VALID;
+}
+
+/* (Re)start timer */
+void bcmos_timer_start(bcmos_timer *timer, uint32_t delay)
+{
+ BUG_ON(!timer);
+ BUG_ON(!BCMOS_TIMER_IS_VALID(timer));
+ if ((int32_t)delay < 0)
+ {
+ BCMOS_TRACE_ERR("Attempt to start timer (%s) for period longer than 2^31-1. Reduced to 2^31-1\n",
+ timer->parm.name ? timer->parm.name : "*unnamed*");
+ delay = 0x7fffffff;
+ }
+
+ if (BCMOS_TIMER_IS_RUNNING(timer) || BCMOS_TIMER_IS_EXPIRED(timer))
+ {
+ _bcmos_timer_stop(timer);
+ }
+ _bcmos_timer_pool_insert(timer, delay, BCMOS_TRUE);
+}
+
+/* Stop timer if running */
+void bcmos_timer_stop(bcmos_timer *timer)
+{
+ BUG_ON(!timer);
+ _bcmos_timer_stop(timer);
+}
+
+/** Set timer handler */
+bcmos_errno bcmos_timer_handler_set(bcmos_timer *timer, F_bcmos_timer_handler handler, long data)
+{
+ BUG_ON(!timer);
+ BUG_ON(!handler);
+ timer->parm.handler = handler;
+ timer->parm.data = data;
+ if (timer->parm.owner == BCMOS_MODULE_ID_NONE)
+ timer->handler = handler;
+ return BCM_ERR_OK;
+}
+
+/*
+ * Block memory pool
+ */
+
+/* Memory block structure:
+ * - bcmos_memblk
+ * - blk_size bytes of user data
+ * - [magic - for block overflow-corruption check]
+ * - [padding to align to pointer size]
+ */
+
+struct bcmos_memblk
+{
+ STAILQ_ENTRY(bcmos_memblk) next; /**< Next block pointer */
+ bcmos_blk_pool *pool; /** pool that owns the block */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /** magic number */
+#define BCMOS_MEM_MAGIC_ALLOC (('m'<<24) | ('b' << 16) | ('l' << 8) | 'k')
+#define BCMOS_MEM_MAGIC_FREE (('m'<<24) | ('b' << 16) | ('l' << 8) | '~')
+#define BCMOS_MEM_MAGIC_SUFFIX (('m'<<24) | ('b' << 16) | ('l' << 8) | 's')
+ uint32_t lineno; /** line number where the block was allocated/released. FFU */
+#endif
+};
+
+/* Create byte memory pool */
+bcmos_errno bcmos_blk_pool_create(bcmos_blk_pool *pool, const bcmos_blk_pool_parm *parm)
+{
+ uint32_t blk_size;
+
+ if (!pool || !parm || !parm->blk_size)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "pool %p, parm %p, blk_size=%u, num_blks=%u\n",
+ pool, parm, parm ? parm->blk_size : 0, parm ? parm->num_blks : 0);
+ }
+ if (parm->num_blks & parm->pool_size)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "One and only one of num_blks (%u) and pool_size (%u) must be set\n",
+ parm->num_blks, parm->pool_size);
+ }
+ if (parm->num_blks && parm->start != NULL)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "num_blks!=0 can't be used with start!=NULL. Use byte size instead\n");
+ }
+
+ BCM_MEMZERO_STRUCT(pool);
+ pool->parm = *parm;
+
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (pool->parm.name)
+ {
+ strncpy(pool->name, pool->parm.name, sizeof(pool->name) - 1);
+ pool->parm.name = pool->name;
+ }
+
+ /*
+ * Calculate total block size in bytes, including overheads
+ */
+ /* Round up block size to the nearest 32-bit word to make MAGIC check cheaper.
+ * It doesn't affect the actual overhead size because of the final
+ * rounding up to pointer size.
+ */
+ pool->parm.blk_size = BCMOS_ROUND_UP(pool->parm.blk_size, sizeof(uint32_t));
+ blk_size = pool->parm.blk_size + sizeof(bcmos_memblk);
+#ifdef BCMOS_MEM_DEBUG
+ blk_size += sizeof(uint32_t); /* room for magic after user data block */
+#endif
+ blk_size = BCMOS_ROUND_UP(blk_size, sizeof(void *));
+
+ /* Derive num_blks / pool_size from one another */
+ if (pool->parm.num_blks)
+ {
+ pool->parm.pool_size = parm->num_blks * blk_size;
+ }
+ else
+ {
+ pool->parm.num_blks = pool->parm.pool_size / blk_size;
+ if (!pool->parm.num_blks)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "pool_size (%u) is too small\n", parm->pool_size);
+ }
+ }
+
+ /* Allocate memory for the pool if "start" is not set */
+ pool->start = pool->parm.start;
+ if (!pool->start)
+ {
+ pool->start = bcmos_alloc(pool->parm.pool_size);
+ if (!pool->start)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "Can't allocate memory for block pool %s\n", parm->name);
+ }
+ }
+
+ bcmos_fastlock_init(&pool->lock, parm->flags);
+
+ /* Put all blocks on free list */
+ bcmos_blk_pool_reset(pool);
+
+ pool->magic = BCMOS_BLK_POOL_VALID;
+ if (!(pool->parm.flags & BCMOS_BLK_POOL_FLAG_MSG_POOL))
+ {
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&blk_pool_list, pool, list);
+ bcmos_total_blk_pool_size += pool->parm.pool_size;
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ }
+
+ return BCM_ERR_OK;
+}
+
+/* Destroy memory pool */
+bcmos_errno bcmos_blk_pool_destroy(bcmos_blk_pool *pool)
+{
+ if (!pool || pool->magic != BCMOS_BLK_POOL_VALID)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "pool handle is invalid\n");
+ }
+ if (pool->stat.free < pool->parm.num_blks)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_STATE, "%i blocks are still allocated from the pool %s\n",
+ pool->parm.num_blks - pool->stat.free, pool->parm.name);
+ }
+ if (!(pool->parm.flags & BCMOS_BLK_POOL_FLAG_MSG_POOL))
+ {
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&blk_pool_list, pool, bcmos_blk_pool, list);
+ bcmos_total_blk_pool_size -= pool->parm.pool_size;
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ }
+ if (!pool->parm.start && pool->start)
+ {
+ bcmos_free(pool->start);
+ }
+ pool->magic = BCMOS_BLK_POOL_DELETED;
+ return BCM_ERR_OK;
+}
+
+/** Release all blocks in memory pool . Block content is not affected */
+void bcmos_blk_pool_reset(bcmos_blk_pool *pool)
+{
+ uint32_t blk_size;
+ bcmos_memblk *blk;
+ uint32_t i;
+
+ STAILQ_INIT(&pool->free_list);
+
+ blk_size = pool->parm.blk_size + sizeof(bcmos_memblk);
+#ifdef BCMOS_MEM_DEBUG
+ blk_size += sizeof(uint32_t); /* room for magic after user data block */
+#endif
+ blk_size = BCMOS_ROUND_UP(blk_size, sizeof(void *));
+
+ /* Put all blocks on free list */
+ blk = (bcmos_memblk *)pool->start;
+ for (i = 0; i < pool->parm.num_blks; i++)
+ {
+ blk->pool = pool;
+ STAILQ_INSERT_TAIL(&pool->free_list, blk, next);
+#ifdef BCMOS_MEM_DEBUG
+ *(uint32_t*)((long)blk + sizeof(bcmos_memblk) + pool->parm.blk_size) = BCMOS_MEM_MAGIC_SUFFIX;
+ blk->lineno = 0;
+ blk->magic = BCMOS_MEM_MAGIC_FREE;
+#endif
+ blk = (bcmos_memblk *)((long)blk + blk_size);
+ }
+
+ /* Init statistics */
+ memset(&pool->stat, 0, sizeof(pool->stat));
+ pool->stat.free = pool->parm.num_blks;
+}
+
+/* Allocate block from block memory pool */
+void *bcmos_blk_pool_alloc(bcmos_blk_pool *pool)
+{
+ bcmos_memblk *blk;
+ long flags;
+
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(!pool);
+ BUG_ON(pool->magic != BCMOS_BLK_POOL_VALID);
+#endif
+ flags = bcmos_fastlock_lock(&pool->lock);
+ blk = STAILQ_FIRST(&pool->free_list);
+ if (blk)
+ {
+ STAILQ_REMOVE_HEAD(&pool->free_list, next);
+ ++pool->stat.allocated;
+#ifdef BCMOS_MEM_DEBUG
+ blk->magic = BCMOS_MEM_MAGIC_ALLOC;
+#endif
+ bcmos_fastlock_unlock(&pool->lock, flags);
+ return (void *)(blk + 1);
+ }
+
+ /* No memory */
+ ++pool->stat.alloc_failed;
+ bcmos_fastlock_unlock(&pool->lock, flags);
+ return NULL;
+}
+
+/* Allocate block from block memory pool and zero the block */
+void *bcmos_blk_pool_calloc(bcmos_blk_pool *pool)
+{
+ void *ptr = bcmos_blk_pool_alloc(pool);
+ if (ptr)
+ {
+ memset(ptr, 0, pool->parm.blk_size);
+ }
+ return ptr;
+}
+
+/* Release memory allocated using bcmos_pool_byte_alloc() or bcmos_pool_blk_alloc() */
+void bcmos_blk_pool_free(void *ptr)
+{
+ bcmos_memblk *blk;
+ bcmos_blk_pool *pool;
+ long flags;
+
+ blk = (bcmos_memblk *)((long)ptr - sizeof(bcmos_memblk));
+ pool = blk->pool;
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(blk->magic != BCMOS_MEM_MAGIC_ALLOC);
+ BUG_ON(pool == NULL);
+ BUG_ON(pool->magic != BCMOS_BLK_POOL_VALID);
+ BUG_ON(*(uint32_t *)((long)ptr + pool->parm.blk_size) != BCMOS_MEM_MAGIC_SUFFIX);
+ blk->magic = BCMOS_MEM_MAGIC_FREE;
+#endif
+ flags = bcmos_fastlock_lock(&pool->lock);
+ STAILQ_INSERT_HEAD(&pool->free_list, blk, next);
+ ++pool->stat.released;
+ bcmos_fastlock_unlock(&pool->lock, flags);
+}
+
+/* Get pool info */
+bcmos_errno bcmos_blk_pool_query(const bcmos_blk_pool *pool, bcmos_blk_pool_info *info)
+{
+ if (!pool || !info)
+ {
+ return BCM_ERR_PARM;
+ }
+ info->parm = pool->parm;
+ info->stat = pool->stat;
+ info->stat.free = pool->parm.num_blks - (info->stat.allocated - info->stat.released);
+ return BCM_ERR_OK;
+}
+
+/* Block pool iterator */
+bcmos_errno bcmos_blk_pool_get_next(const bcmos_blk_pool **prev)
+{
+ const bcmos_blk_pool *pool;
+
+ if (prev == NULL)
+ {
+ return BCM_ERR_PARM;
+ }
+ pool = *prev;
+ if (pool && pool->magic != BCMOS_BLK_POOL_VALID)
+ {
+ return BCM_ERR_PARM;
+ }
+ if (pool)
+ {
+ pool = STAILQ_NEXT(pool, list);
+ }
+ else
+ {
+ pool = STAILQ_FIRST(&blk_pool_list);
+ }
+ *prev = pool;
+ if (!pool)
+ {
+ return BCM_ERR_NO_MORE;
+ }
+ return BCM_ERR_OK;
+}
+
+/*
+ * Message pool
+ */
+
+/* release message callback */
+static void _bcmos_msg_pool_release(bcmos_msg *msg)
+{
+ if (msg->data_release)
+ msg->data_release(msg);
+ bcmos_blk_pool_free(msg);
+}
+
+/* Create message pool */
+bcmos_errno bcmos_msg_pool_create(bcmos_msg_pool *pool, const bcmos_msg_pool_parm *parm)
+{
+ bcmos_blk_pool_parm pool_parm = {};
+ bcmos_memblk *blk;
+ bcmos_errno err;
+
+ if (!pool || !parm || !parm->size)
+ {
+ return BCM_ERR_PARM;
+ }
+ BCM_MEMZERO_STRUCT(pool);
+ pool->parm = *parm;
+ pool_parm.num_blks = parm->size;
+ pool_parm.blk_size = parm->data_size + sizeof(bcmos_msg);
+ pool_parm.flags = parm->flags | BCMOS_BLK_POOL_FLAG_MSG_POOL;
+ pool_parm.name = parm->name;
+
+ /* Create underlying block pool */
+ err = bcmos_blk_pool_create(&pool->blk_pool, &pool_parm);
+ if (err)
+ {
+ return err;
+ }
+ pool->parm.name = pool->blk_pool.name;
+
+ /* Pre-initialize all messages */
+ STAILQ_FOREACH(blk, &pool->blk_pool.free_list, next)
+ {
+ bcmos_msg *msg = (bcmos_msg *)(blk + 1);
+ msg->data = (void *)(msg + 1);
+ msg->size = pool->parm.data_size;
+ msg->release = _bcmos_msg_pool_release;
+ msg->data_release = parm->data_release;
+ }
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&msg_pool_list, &pool->blk_pool, list);
+ bcmos_total_msg_pool_size += pool->blk_pool.parm.pool_size;
+ bcmos_mutex_unlock(&bcmos_res_lock);
+
+ return BCM_ERR_OK;
+}
+
+/** Destroy message pool */
+bcmos_errno bcmos_msg_pool_destroy(bcmos_msg_pool *pool)
+{
+ bcmos_errno rc;
+
+ rc = bcmos_blk_pool_destroy(&pool->blk_pool);
+ if (rc)
+ return rc;
+
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&msg_pool_list, &pool->blk_pool, bcmos_blk_pool, list);
+ bcmos_total_msg_pool_size -= pool->blk_pool.parm.pool_size;
+ bcmos_mutex_unlock(&bcmos_res_lock);
+
+ pool->parm.size = pool->parm.data_size = 0;
+ return BCM_ERR_OK;
+}
+
+/* Allocate message from pool */
+bcmos_msg *bcmos_msg_pool_alloc(bcmos_msg_pool *pool)
+{
+ return bcmos_blk_pool_alloc(&pool->blk_pool);
+}
+
+/* Get pool info */
+bcmos_errno bcmos_msg_pool_query(const bcmos_msg_pool *pool, bcmos_msg_pool_info *info)
+{
+ bcmos_blk_pool_info pool_info;
+ bcmos_errno err;
+
+ if (!pool || !info)
+ {
+ return BCM_ERR_PARM;
+ }
+ err = bcmos_blk_pool_query(&pool->blk_pool, &pool_info);
+ if (err)
+ {
+ return err;
+ }
+ info->parm = pool->parm;
+ info->stat = pool_info.stat;
+ return BCM_ERR_OK;
+}
+
+/* Block pool iterator */
+bcmos_errno bcmos_msg_pool_get_next(const bcmos_msg_pool **prev)
+{
+ const bcmos_msg_pool *pool;
+
+ if (prev == NULL)
+ {
+ return BCM_ERR_PARM;
+ }
+ pool = *prev;
+ if (pool && pool->blk_pool.magic != BCMOS_BLK_POOL_VALID)
+ {
+ return BCM_ERR_PARM;
+ }
+ if (pool)
+ {
+ pool = container_of(STAILQ_NEXT(&pool->blk_pool, list), bcmos_msg_pool, blk_pool);
+ }
+ else
+ {
+ pool = container_of(STAILQ_FIRST(&msg_pool_list), bcmos_msg_pool, blk_pool);
+ }
+ *prev = pool;
+ if (!pool)
+ {
+ return BCM_ERR_NO_MORE;
+ }
+ return BCM_ERR_OK;
+}
+
+/** Set up print redirection/cloning
+ * \param[in] mode redirection/cloning mode
+ * \param[in] cb redirection callback
+ * \param[in] data opaque data to be passed to cb
+ */
+bcmos_errno bcmos_print_redirect(bcmos_print_redirect_mode mode, bcmos_print_redirect_cb cb, void *data)
+{
+ if (mode != BCMOS_PRINT_REDIRECT_MODE_NONE && cb == NULL)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Redirection callback must be set\n");
+ }
+ print_redirect_mode = mode;
+ if (mode == BCMOS_PRINT_REDIRECT_MODE_NONE)
+ {
+ print_redirect_cb = NULL;
+ print_redirect_cb_data = NULL;
+ }
+ else
+ {
+ print_redirect_cb = cb;
+ print_redirect_cb_data = data;
+ }
+ return BCM_ERR_OK;
+}
+
+/* Print on the console with optional cloning / redirection */
+/*lint -e{454}*/
+int bcmos_vprintf(const char *format, va_list ap)
+{
+ int rc = 0;
+ bcmos_bool protected_section = is_irq_mode() || is_irq_disabled();
+
+ /* Only protect if in task context */
+ if (!protected_section)
+ {
+ bcmos_mutex_lock(&bcmos_print_lock);
+ }
+ if (print_redirect_mode != BCMOS_PRINT_REDIRECT_MODE_REDIRECT)
+ {
+ rc = bcmos_sys_vprintf(format, ap);
+ }
+ if (print_redirect_mode != BCMOS_PRINT_REDIRECT_MODE_NONE)
+ {
+ rc = print_redirect_cb(print_redirect_cb_data, format, ap);
+ }
+ if (!protected_section)
+ {
+ bcmos_mutex_unlock(&bcmos_print_lock);
+ }
+
+ return rc;
+}
+/*lint -e{454}*/
+
+/* Print on the console with optional cloning / redirection */
+int bcmos_printf(const char *format, ...)
+{
+ va_list args;
+ int rc;
+
+ va_start(args, format);
+ rc = bcmos_vprintf(format, args);
+ va_end(args);
+ return rc;
+}
+
+#ifndef BCMOS_PUTCHAR_INLINE
+/*lint -e{454}*/
+void bcmos_putchar(int c)
+{
+ bcmos_bool protected_section = is_irq_mode() || is_irq_disabled();
+
+ /* Only protect if in task context */
+ if (!protected_section)
+ {
+ bcmos_mutex_lock(&bcmos_print_lock);
+ }
+ putchar(c);
+ fflush(stdout);
+ if (!protected_section)
+ {
+ bcmos_mutex_unlock(&bcmos_print_lock);
+ }
+}
+/*lint +e{454}*/
+#endif
+
+#ifndef BCMOS_BUF_OS_SPECIFIC
+
+/*
+ * Buffer allocation/release
+ */
+
+#ifdef BCMOS_BUF_POOL_SIZE
+/** Create buffer pool
+ * \param[in] num Number of buffers
+ * \param[in] size Buffer size
+ * \param[in] align Buffer alignment
+ * \returns o=OK or error <0
+ */
+static bcmos_errno bcmos_buf_pool_create(void)
+{
+ bcmos_blk_pool_parm pool_parm =
+ {
+ .name = "sysbuf"
+ };
+ bcmos_errno rc;
+
+#ifndef BCMOS_BUF_POOL_BUF_SIZE
+#error BCMOS_BUF_POOL_BUF_SIZE must be defined
+#endif
+
+ /* If buffer memory should be allocated by bcmos_dma_alloc - allocate
+ * memory for the whole pool here */
+ pool_parm.blk_size = BCMOS_BUF_POOL_BUF_SIZE + sizeof(bcmos_buf) + BCMTR_BUF_EXTRA_HEADROOM +
+ 2*BCMOS_BUF_DATA_ALIGNMENT + BCMOS_BUF_DATA_GUARD;
+
+#ifdef BCMOS_BUF_IN_DMA_MEM
+ pool_parm.pool_size = (pool_parm.blk_size + sizeof(bcmos_memblk)) * BCMOS_BUF_POOL_SIZE;
+ pool_parm.start = bcmos_dma_alloc(0, pool_parm.pool_size);
+ if (!pool_parm.start)
+ return BCM_ERR_NOMEM;
+#else
+ pool_parm.num_blks = BCMOS_BUF_POOL_SIZE;
+#endif
+
+ rc = bcmos_blk_pool_create(&sys_buf_pool, &pool_parm);
+ if (rc)
+ {
+ if (pool_parm.start)
+ bcmos_dma_free(0, pool_parm.start);
+ }
+
+ return rc;
+}
+#endif
+
+/* Allocate buffer */
+bcmos_buf *bcmos_buf_alloc(uint32_t size)
+{
+ /* Allocate extra 2 * BCMOS_BUF_DATA_ALIGNMENT to make sure that neither data start nor end
+ * end up in the middle of cache line
+ */
+ bcmos_buf *buf;
+
+/* Allocate from the pool */
+#ifdef BCMOS_BUF_POOL_SIZE
+
+ if (size > BCMOS_BUF_POOL_BUF_SIZE)
+ {
+ BCMOS_TRACE_ERR("Attempt to allocate buffer bigger than buffer pool block size. %u > %u\n",
+ size, BCMOS_BUF_POOL_BUF_SIZE);
+ return NULL;
+ }
+ buf = bcmos_blk_pool_alloc(&sys_buf_pool);
+
+#else /* else of #if BCMOS_BUF_POOL_SIZE */
+ {
+ uint32_t alloc_size = sizeof(bcmos_buf) + size + BCMTR_BUF_EXTRA_HEADROOM +
+ 2*BCMOS_BUF_DATA_ALIGNMENT - 1 + BCMOS_BUF_DATA_GUARD;
+#ifdef BCMOS_BUF_DATA_UNIT_SIZE
+#if BCMOS_BUF_DATA_UNIT_SIZE & (BCMOS_BUF_DATA_UNIT_SIZE - 1)
+#error BCMOS_BUF_DATA_UNIT_SIZE must be a power of 2
+#endif
+ alloc_size = BCMOS_ROUND_UP(alloc_size, BCMOS_BUF_DATA_UNIT_SIZE);
+#endif
+#ifdef BCMOS_BUF_IN_DMA_MEM
+ buf = bcmos_dma_alloc(0, alloc_size);
+#else
+ buf = bcmos_alloc(alloc_size);
+#endif
+ }
+#endif /* end of #if BCMOS_BUF_POOL_SIZE */
+
+ if (!buf)
+ return NULL;
+ buf->start = (uint8_t *)(buf + 1) + BCMOS_BUF_DATA_GUARD;
+ buf->data = (uint8_t *)(BCMOS_ROUND_UP((long)buf->start + BCMTR_BUF_EXTRA_HEADROOM, BCMOS_BUF_DATA_ALIGNMENT));
+ buf->size = size + (buf->data - buf->start);
+ buf->len = 0;
+#ifdef BCMOS_BUF_POOL_SIZE
+ buf->pool = &sys_buf_pool;
+#else
+ buf->pool = NULL;
+#endif
+ return buf;
+}
+
+/* Release buffer */
+void bcmos_buf_free(bcmos_buf *buf)
+{
+
+#ifdef BCMOS_BUF_POOL_SIZE
+ /* Buffer might have been allocated from the system pool */
+ if (buf->pool)
+ {
+ bcmos_blk_pool_free(buf);
+ return;
+ }
+#endif
+
+#ifdef BCMOS_BUF_IN_DMA_MEM
+ bcmos_dma_free(0, buf);
+#else
+ bcmos_free(buf);
+#endif
+}
+
+#endif
+
+EXPORT_SYMBOL(bcmos_init);
+
+EXPORT_SYMBOL(bcmos_msg_queue_create);
+EXPORT_SYMBOL(bcmos_msg_queue_destroy);
+EXPORT_SYMBOL(bcmos_msg_queue_query);
+EXPORT_SYMBOL(bcmos_msg_queue_get_next);
+EXPORT_SYMBOL(bcmos_msg_send);
+EXPORT_SYMBOL(bcmos_msg_send_to_module);
+EXPORT_SYMBOL(bcmos_msg_recv);
+EXPORT_SYMBOL(bcmos_msg_register);
+EXPORT_SYMBOL(bcmos_msg_unregister);
+EXPORT_SYMBOL(bcmos_msg_dispatch);
+
+EXPORT_SYMBOL(bcmos_msg_qgroup_create);
+EXPORT_SYMBOL(bcmos_msg_qgroup_destroy);
+EXPORT_SYMBOL(bcmos_msg_qgroup_query);
+EXPORT_SYMBOL(bcmos_msg_recv_from_qgroup);
+EXPORT_SYMBOL(bcmos_msg_send_to_qgroup);
+
+EXPORT_SYMBOL(bcmos_task_timeout_set);
+EXPORT_SYMBOL(bcmos_task_get_next);
+
+EXPORT_SYMBOL(bcmos_module_create);
+EXPORT_SYMBOL(bcmos_module_destroy);
+EXPORT_SYMBOL(bcmos_module_current);
+EXPORT_SYMBOL(bcmos_module_context);
+EXPORT_SYMBOL(bcmos_module_context_set);
+EXPORT_SYMBOL(bcmos_module_query);
+
+EXPORT_SYMBOL(bcmos_event_create);
+EXPORT_SYMBOL(bcmos_event_destroy);
+EXPORT_SYMBOL(bcmos_event_raise);
+EXPORT_SYMBOL(bcmos_event_recv);
+
+EXPORT_SYMBOL(bcmos_timer_create);
+EXPORT_SYMBOL(bcmos_timer_destroy);
+EXPORT_SYMBOL(bcmos_timer_start);
+EXPORT_SYMBOL(bcmos_timer_stop);
+EXPORT_SYMBOL(bcmos_timer_handler_set);
+
+EXPORT_SYMBOL(bcmos_blk_pool_create);
+EXPORT_SYMBOL(bcmos_blk_pool_destroy);
+EXPORT_SYMBOL(bcmos_blk_pool_reset);
+EXPORT_SYMBOL(bcmos_blk_pool_alloc);
+EXPORT_SYMBOL(bcmos_blk_pool_calloc);
+EXPORT_SYMBOL(bcmos_blk_pool_free);
+EXPORT_SYMBOL(bcmos_blk_pool_query);
+EXPORT_SYMBOL(bcmos_blk_pool_get_next);
+
+EXPORT_SYMBOL(bcmos_msg_pool_create);
+EXPORT_SYMBOL(bcmos_msg_pool_alloc);
+EXPORT_SYMBOL(bcmos_msg_pool_query);
+EXPORT_SYMBOL(bcmos_msg_pool_destroy);
+EXPORT_SYMBOL(bcmos_msg_pool_get_next);
+
+EXPORT_SYMBOL(bcmos_print_redirect);
+EXPORT_SYMBOL(bcmos_printf);
+EXPORT_SYMBOL(bcmos_vprintf);
+
+#ifndef BCMOS_BUF_OS_SPECIFIC
+EXPORT_SYMBOL(bcmos_buf_alloc);
+EXPORT_SYMBOL(bcmos_buf_free);
+#endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_common.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_common.h
new file mode 100644
index 0000000..da09c1c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_common.h
@@ -0,0 +1,1479 @@
+/*
+<: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 BCMOS_COMMON_H_
+#define BCMOS_COMMON_H_
+
+#ifndef BCMOS_SYSTEM_H_
+#error Please do not include bcmos_common.h directly. Include bcmos_system.h
+#endif
+
+#include "bcmos_errno.h"
+#include "bcmos_types.h"
+#include "bcmos_queue.h"
+#include "bcmos_tree.h"
+/* Get constants, such as task, module, event id lists */
+#include "bcmos_platform.h"
+#include "bcmos_pack.h"
+#include "bcmos_sysif.h"
+
+#define MAX_TASK_NAME_SIZE 64
+#define MAX_MODULE_NAME_SIZE 64
+#define MAX_MSG_QUEUE_NAME_SIZE 64
+#define MAX_TIMER_NAME_SIZE 64
+#define MAX_POOL_NAME_SIZE 64
+#define MAX_EVENT_NAME_SIZE 64
+#define MAX_MUTEX_NAME_SIZE 64
+#define BCMOS_MSG_POOL_DEFAULT_SIZE 512
+
+/* Define bcmos_bool - the boolean type for bcmos - based on C99 standard boolean type */
+#ifndef BCMOS_BOOLEAN
+typedef _Bool bcmos_bool;
+#define BCMOS_FALSE 0
+#define BCMOS_TRUE 1
+#endif
+
+#define BCM_SIZEOFARRAY(arr) (sizeof(arr)/sizeof(*arr))
+#define BCM_SIZEOFFIELD(s, f) (sizeof(((s*)NULL)->f))
+#define BCM_MEMZERO_STRUCT(ptr) memset(ptr, 0, sizeof(*(ptr)))
+#define BCM_MEMCPY_ARRAY(dst, src) memcpy(dst, src, sizeof(dst))
+#define TAB " "
+#define TAB2 TAB TAB
+#define TAB3 TAB2 TAB
+#define TAB4 TAB2 TAB2
+
+#define CHIP_REVISION_A0 0xA0
+#define CHIP_REVISION_B0 0xB0
+
+#ifdef SIMULATION_BUILD
+#define GET_CHIP_REVISION CHIP_REVISION_A0
+#else
+extern uint32_t chip_revision;
+#define GET_CHIP_REVISION (chip_revision != 0 ? chip_revision : (chip_revision = get_chip_revision()))
+#endif
+
+typedef void (*f_bcmolt_sw_error_handler)(uint8_t pon_id, const char *file_name, uint32_t line_number);
+
+/* Similar to BUG_ON(), with the following features:
+ * 1. The condition is checked against BCM_ERR_OK.
+ * 2. In case on an error, the macro returns from the calling function with the error code. */
+#define BUG_ON_ERR_RET(f) \
+ do \
+ { \
+ bcmos_errno _err; \
+ _err = f; \
+ BUG_ON(_err != BCM_ERR_OK); \
+ return _err; \
+ } \
+ while (0)
+
+/** \addtogroup system_init
+ * @{
+ */
+
+/** Initialize system library
+ * Must be called before any other system function
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_init(void);
+
+/** Cleanup system library
+ */
+void bcmos_exit(void);
+
+/** @} system_init */
+
+/** \addtogroup system_mem
+ * @{
+ */
+
+#ifndef BCMOS_MALLOC_FREE_INLINE
+
+/** \defgroup system_heap Default Heap
+ * @{
+ */
+
+/** Allocate memory from the main heap
+ * \param[in] size
+ * \returns memory block pointer or NULL
+ */
+void *bcmos_alloc(uint32_t size);
+
+/** Release memory to the main pool
+ * \param[in] ptr
+ */
+void bcmos_free(void *ptr);
+
+/** @} system_heap */
+
+#endif /* #ifndef BCMOS_MALLOC_FREE_INLINE */
+
+/** \defgroup blk_pool Block Memory Pool
+ * \ingroup system_mem
+ * @{
+ */
+
+/** Block memory pool parameters */
+typedef struct
+{
+ const char *name; /**< Pool name */
+ uint32_t blk_size; /**< Memory block size > 0 */
+ uint32_t num_blks; /**< Number of blocks in the pool. If not set - it is derived from pool_size */
+ void *start; /**< Start address. Can be NULL */
+ uint32_t pool_size; /**< Total pool size in bytes. Only 1 of pool_size, num_blks must be set */
+ uint32_t flags; /**< TBD flags */
+#define BCMOS_BLK_POOL_FLAG_MSG_POOL 0x80000000 /* Used by message pool */
+} bcmos_blk_pool_parm;
+
+/** Block memory pool statistics */
+typedef struct bcmos_blk_pool_stat
+{
+ uint32_t allocated; /**< Number of blocks allocated */
+ uint32_t released; /**< Number of blocks released */
+ uint32_t free; /**< Number of free blocks in the pool */
+ uint32_t alloc_failed; /**< Number of allocation failures */
+} bcmos_blk_pool_stat;
+
+/** Block memory pool info */
+typedef struct bcmos_blk_pool_info
+{
+ bcmos_blk_pool_parm parm; /**< Pool parameters */
+ bcmos_blk_pool_stat stat; /**< Pool statistics */
+} bcmos_blk_pool_info;
+
+/** Block memory pool control block */
+typedef struct bcmos_blk_pool bcmos_blk_pool;
+
+/** Create block memory pool
+ * \param[in,out] pool pool control block
+ * \param[in] parm pool parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_blk_pool_create(bcmos_blk_pool *pool, const bcmos_blk_pool_parm *parm);
+
+/** Destroy block memory pool
+ * \param[in] pool pool handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_blk_pool_destroy(bcmos_blk_pool *pool);
+
+/** Allocate block from block memory pool
+ *
+ * This allocates a single unit (unit_size bytes)
+ * \param[in] pool Pool handle
+ * \return memory block pointer or NULL.
+ * It is guaranteed that the returned pointer is aligned to pointer size
+ */
+void *bcmos_blk_pool_alloc(bcmos_blk_pool *pool);
+
+/** Allocate block from block memory pool and zero the block
+ *
+ * This allocates a single unit (unit_size bytes)
+ * \param[in] pool Pool handle
+ * \return memory block pointer or NULL.
+ * It is guaranteed that the returned pointer is aligned to pointer size
+ */
+void *bcmos_blk_pool_calloc(bcmos_blk_pool *pool);
+
+/** Release memory allocated using bcmos_blk_pool_alloc()
+ *
+ * \param[in] ptr pointer
+ */
+void bcmos_blk_pool_free(void *ptr);
+
+/** Release all blocks in memory pool. Block content is not affected
+ * This function is useful when application wants to pre-initialize
+ * some portion of each memory block at init time
+ *
+ * \param[in] pool Pool handle
+ */
+void bcmos_blk_pool_reset(bcmos_blk_pool *pool);
+
+/** Get pool info
+ *
+ * The pool must be created using bcmos_blk_pool_create()
+ * \param[in] pool Block memory pool handle
+ * \param[out] info Block memory pool info
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_blk_pool_query(const bcmos_blk_pool *pool, bcmos_blk_pool_info *info);
+
+/** Block pool iterator
+ * \param[in] prev Previous block pool. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_blk_pool_get_next(const bcmos_blk_pool **prev);
+
+/** @} blk_pool */
+
+/** \defgroup byte_pool Byte Memory Pool
+ * \ingroup system_mem
+ * @{
+ */
+
+/** Byte memory pool parameters */
+typedef struct
+{
+ const char *name; /**< Pool name */
+ uint32_t size; /**< Pool size (bytes) */
+ void *start; /**< Start address. Can be NULL */
+} bcmos_byte_pool_parm;
+
+/** Byte memory pool control block */
+typedef struct bcmos_byte_pool bcmos_byte_pool;
+
+/** Create byte memory pool
+ * \param[in,out] pool pool control block
+ * \param[in] parm pool parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_byte_pool_create(bcmos_byte_pool *pool, const bcmos_byte_pool_parm *parm);
+
+/** Destroy byte memory pool
+ * \param[in] pool pool handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_byte_pool_destroy(bcmos_byte_pool *pool);
+
+#ifndef BCMOS_BYTE_POOL_ALLOC_FREE_INLINE
+/** Allocate memory from byte memory pool
+ *
+ * This function can only be used with byte memory pools created
+ * with unit_size==1
+ * \param[in] pool Pool handle
+ * \param[in] size Block size (bytes)
+ * \return memory block pointer or NULL
+ */
+void *bcmos_byte_pool_alloc(bcmos_byte_pool *pool, uint32_t size);
+
+/** Release memory allocated using bcmos_pool_byte_alloc()
+ *
+ * \param[in] ptr pointer
+ */
+void bcmos_byte_pool_free(void *ptr);
+
+#endif /* BCMOS_BYTE_POOL_ALLOC_FREE_INLINE */
+
+/** @} byte_pool */
+
+/** @} system_mem */
+
+/** \addtogroup system_task
+ * @{
+ */
+#ifndef BCMOS_WAIT_FOREVER
+#define BCMOS_WAIT_FOREVER 0xFFFFFFFF /**< Wait timeout. Wait forever */
+#endif
+#ifndef BCMOS_NO_WAIT
+#define BCMOS_NO_WAIT 0 /**< Wait timeout. Don't wait */
+#endif
+#define BCMOS_MICROSECONDS_IN_SECONDS (1000000)
+
+/** Task priority */
+typedef enum
+{
+ BCMOS_TASK_PRIORITY_0, /**< Priority 0 - highest */
+ BCMOS_TASK_PRIORITY_1, /**< Priority 1 */
+ BCMOS_TASK_PRIORITY_2, /**< Priority 2 */
+ BCMOS_TASK_PRIORITY_3, /**< Priority 3 */
+ BCMOS_TASK_PRIORITY_4, /**< Priority 4 */
+ BCMOS_TASK_PRIORITY_5, /**< Priority 5 */
+ BCMOS_TASK_PRIORITY_6, /**< Priority 6 */
+ BCMOS_TASK_PRIORITY_7, /**< Priority 7 */
+ BCMOS_TASK_PRIORITY_8, /**< Priority 8 */
+ BCMOS_TASK_PRIORITY_9, /**< Priority 9 */
+ BCMOS_TASK_PRIORITY_10,/**< Priority 10 */
+ BCMOS_TASK_PRIORITY_11,/**< Priority 11 */
+ BCMOS_TASK_PRIORITY_12,/**< Priority 12 */
+ BCMOS_TASK_PRIORITY_13,/**< Priority 13 */
+ BCMOS_TASK_PRIORITY_14,/**< Priority 14 */
+ BCMOS_TASK_PRIORITY_15,/**< Priority 15 */
+ BCMOS_TASK_PRIORITY_16,/**< Priority 16 */
+ BCMOS_TASK_PRIORITY_17,/**< Priority 17 */
+ BCMOS_TASK_PRIORITY_18,/**< Priority 18 */
+ BCMOS_TASK_PRIORITY_19,/**< Priority 19 */
+ BCMOS_TASK_PRIORITY_20,/**< Priority 20 */
+ BCMOS_TASK_PRIORITY_21,/**< Priority 21 */
+ BCMOS_TASK_PRIORITY_22,/**< Priority 22 */
+ BCMOS_TASK_PRIORITY_23,/**< Priority 23 */
+ BCMOS_TASK_PRIORITY_24,/**< Priority 24 */
+ BCMOS_TASK_PRIORITY_25,/**< Priority 25 */
+ BCMOS_TASK_PRIORITY_26,/**< Priority 26 */
+ BCMOS_TASK_PRIORITY_27,/**< Priority 27 */
+ BCMOS_TASK_PRIORITY_28,/**< Priority 28 */
+ BCMOS_TASK_PRIORITY_29,/**< Priority 29 */
+ BCMOS_TASK_PRIORITY_30,/**< Priority 30 */
+ BCMOS_TASK_PRIORITY_31,/**< Priority 31 - lowest */
+} bcmos_task_priority;
+
+/** Task handler */
+typedef int (*F_bcmos_task_handler)(long data);
+
+/* Default task handler */
+extern int bcmos_dft_task_handler(long data);
+
+/* This flags determines whether a task is to be suspended upon OOPS condition. */
+#define BCMOS_TASK_FLAG_NO_SUSPEND_ON_OOPS (1 << 0)
+
+/** Task parameters */
+typedef struct
+{
+ const char *name; /**< Task name */
+ bcmos_task_priority priority; /**< Task priority */
+ bcmos_core core; /**< CPU core the task is locked to */
+ uint32_t stack_size; /**< Task stack size */
+ void *stack; /**< Stack location. NULL=allocate automatically */
+ F_bcmos_task_handler init_handler; /**< Optional "init" handler. Called once in the task context when it is created.
+ This callback is only supported in integration mode (handler==NULL).
+ init_handler returns bcmos_errno. If it returns value other than BCM_ERR_OK,
+ the task is destroyed */
+ F_bcmos_task_handler handler; /**< Task handler. NULL=default (integration mode) */
+ F_bcmos_task_handler timeout_handler;/**< This function is used only in integration mode (handler==NULL) if
+ msg_wait_timeout is > 0. It is called if there were no messages for the task
+ for longer than msg_wait_timeout us.
+ If timeout handler returns value other than BCM_ERR_OK, task terminates.
+ */
+ uint32_t msg_wait_timeout; /**< This parameter is used only in integration mode (handler==NULL) together with
+ timeout_handler. If > 0 and there were no messages for longer than
+ msg_wait_timeout us, timeout_handler is called.
+ */
+ long data; /**< Data passed to the task handler */
+ uint32_t flags; /**< flags */
+} bcmos_task_parm;
+
+/** Task control block */
+typedef struct bcmos_task bcmos_task;
+
+/** Create a new task
+ *
+ * \param[in,out] task Task control block
+ * \param[in] parm Task parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_task_create(bcmos_task *task, const bcmos_task_parm *parm);
+
+/** Set task timeout
+ *
+ * This function is only used in integration mode (handler==NULL).
+ * It sets max time the default task handler waits for message directed to one of the
+ * task's modules.
+ *
+ * \param[in,out] task Task control block
+ * \param[in] timeout Max time (us) to wait for messages. 0=FOREVER
+ * Changing timeout from infinite to finite only takes effect
+ * after message is received by any task module.
+ * \param[in] timeout_handler Handler to be called upon timeout. Must be != NULL if timeout > 0.
+ * If the handler returns error (!= BCM_ERR_OK), task terminates.
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_task_timeout_set(bcmos_task *task, uint32_t timeout, F_bcmos_task_handler timeout_handler);
+
+/** Destroy task
+ *
+ * \param[in] task Task handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_task_destroy(bcmos_task *task);
+
+/** Get current task
+ * \returns task handle or NULL if not in task context
+ */
+bcmos_task *bcmos_task_current(void);
+
+/** Query task info
+ * \param[in] task Task control block
+ * \param[out] parm Task parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_task_query(const bcmos_task *task, bcmos_task_parm *parm);
+
+/** Task iterator
+ * \param[in] prev Previous task. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_task_get_next(bcmos_task **prev);
+
+
+/** @} system_task */
+
+/** \addtogroup system_msg
+ * @{
+ */
+
+/** Message header */
+typedef struct bcmos_msg bcmos_msg;
+
+/** Message queue control block */
+typedef struct bcmos_msg_queue bcmos_msg_queue;
+
+/** Message queue group control block */
+typedef struct bcmos_msg_qgroup bcmos_msg_qgroup;
+
+#if defined(BCMOS_MSG_QUEUE_DOMAIN_SOCKET) || defined(BCMOS_MSG_QUEUE_UDP_SOCKET) || defined(BCMOS_MSG_QUEUE_USER_DEFINED)
+#define BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+#endif
+
+/** Message queue endpoint type */
+typedef enum
+{
+ BCMOS_MSG_QUEUE_EP_LOCAL, /**< Local endpoint (inter-thread communication) */
+#ifdef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+ BCMOS_MSG_QUEUE_EP_DOMAIN_SOCKET, /**< Domain-socket based endpoint */
+#endif
+#ifdef BCMOS_MSG_QUEUE_UDP_SOCKET
+ BCMOS_MSG_QUEUE_EP_UDP_SOCKET, /**< UDP socket-based endpoint */
+#endif
+#ifdef BCMOS_MSG_QUEUE_USER_DEFINED
+ BCMOS_MSG_QUEUE_EP_USER_DEFINED /**< User-defined endpoint */
+#endif
+} bcmos_msg_queue_ep_type;
+
+
+/** Message queue parameters */
+typedef struct
+{
+ const char *name; /**< Queue name (for logging and debugging) */
+ uint32_t size; /**< Max queue size. 0=unlimited */
+ uint32_t high_wm; /**< Optional high water mark. Log is generated when queue occupancy exceeds hwm */
+ uint32_t low_wm; /**< Optional low water mark. Log is generated when queue occupancy drops below lwm */
+ uint32_t flags; /**< TBD flags. For example, single-core, m-core */
+ void (*notify)(bcmos_msg_queue *q, const char *txt); /***< Called when queue congestion state changes */
+ bcmos_msg_queue_ep_type ep_type; /**< Queue endpoint type */
+
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+ /* Remote message queue support allows queue endpoints to be located in
+ * different processes or even processors.
+ */
+ const char *local_ep_address; /**< Queue local endpoint address */
+ const char *remote_ep_address; /**< Queue local endpoint address */
+
+ uint32_t max_mtu; /**< Max MTU size */
+#define BCMOS_MSG_QUEUE_DEFAULT_MAX_MTU (64*1024)
+
+ /** Optional "pack" callback. Not needed if 2 processes are on the same core. */
+ bcmos_errno (*pack)(bcmos_msg_queue *queue, bcmos_msg *msg, uint8_t **buf, uint32_t *buf_length);
+
+ /** Optional "unpack" callback. Not needed if 2 processes are on the same core. */
+ bcmos_errno (*unpack)(bcmos_msg_queue *queue, uint8_t *buf, uint32_t buf_length, bcmos_msg **msg);
+
+ /** Optional callback that releases packed buffer */
+ void (*free_packed)(bcmos_msg_queue *queue, uint8_t *buf);
+
+ /** Optional "open" callback. Must be set for user-defined queue, NULL otherwise */
+ bcmos_errno (*open)(bcmos_msg_queue *queue);
+
+ /** Optional "close" callback. Must be set for user-defined queue, NULL otherwise */
+ bcmos_errno (*close)(bcmos_msg_queue *queue);
+
+ /** Optional "send" callback. Must be set for user-defined queue, NULL otherwise */
+ bcmos_errno (*send)(bcmos_msg_queue *queue, uint8_t *buf, uint32_t buf_length);
+
+ /** Optional "recv" callback. Must be set for user-defined queue, NULL otherwise */
+ bcmos_errno (*recv)(bcmos_msg_queue *queue, uint32_t timeout, uint8_t **buf, uint32_t *buf_length);
+#endif
+
+} bcmos_msg_queue_parm;
+
+/** Message queue statistics */
+typedef struct
+{
+ uint32_t msg_in; /**< Number of messages currently in the queue */
+ uint32_t msg_sent; /**< Number of messages successfully submitted into the queue */
+ uint32_t msg_received; /**< Number of messages received from the queue */
+ uint32_t msg_discarded; /**< Number of messages discarded because of queue overflow */
+ uint32_t msg_almost_full; /**< Number of messages submitted to queue when it was above high water mark */
+ bcmos_bool is_congested; /**< True=the queue is currently congested */
+} bcmos_msg_queue_stat;
+
+/** Message queue info */
+typedef struct
+{
+ bcmos_msg_queue_parm parm; /**< Queue parameters */
+ bcmos_msg_queue_stat stat; /**< Queue statistics */
+} bcmos_msg_queue_info;
+
+/** Message priority in queue group */
+typedef uint32_t bcmos_qgroup_prty;
+
+/** Message queue group parameters */
+typedef struct
+{
+ const char *name; /**< Queue group name (for logging and debugging) */
+ bcmos_qgroup_prty nqueues; /**< Number of queues in the group */
+ uint32_t size; /**< Total number of messages that can be stored in queue group. 0=unlimited */
+ uint32_t high_wm; /**< Optional high water mark. Log is generated when queue occupancy exceeds hwm */
+ uint32_t low_wm; /**< Optional low water mark. Log is generated when queue occupancy drops below lwm */
+ uint32_t flags; /**< TBD flags. For example, single-core, m-core */
+ void (*notify)(bcmos_msg_qgroup *qgrp, const char *txt); /***< Called when queue group congestion state changes */
+} bcmos_msg_qgroup_parm;
+
+/** Message queue group info */
+typedef struct
+{
+ bcmos_msg_qgroup_parm parm; /**< Queue group parameters */
+ bcmos_msg_queue_stat stat; /**< Queue group statistics */
+} bcmos_msg_qgroup_info;
+
+/** Message recipient instance (e.g., optical link id) */
+typedef uint16_t bcmos_msg_instance;
+
+/** Message send flags */
+typedef enum
+{
+ BCMOS_MSG_SEND_AUTO_FREE = 0x00000000, /**< Automatically release message in case of error. This is the default behaviour */
+ BCMOS_MSG_SEND_NO_FREE_ON_ERROR =0x00000001,/**< Do NOT free message in case of transmit error */
+ BCMOS_MSG_SEND_URGENT = 0x00000002, /**< Urgent message */
+ BCMOS_MSG_SEND_NOLIMIT = 0x00000004, /**< Ignore destination queue size limit */
+} bcmos_msg_send_flags;
+
+/** Registered message handler */
+typedef void (*F_bcmos_msg_handler)(bcmos_module_id module_id, bcmos_msg *msg);
+typedef bcmos_errno (*F_bcmos_module_init)(long data);
+typedef void (*F_bcmos_module_exit)(long data);
+
+/** Message header */
+struct bcmos_msg
+{
+ bcmos_msg_id type; /**< Message type */
+ bcmos_msg_instance instance;/**< Message recipient instance (e.g., optical link id) */
+ F_bcmos_msg_handler handler;/**< Message handler. Can be set by the sender or message dispatcher */
+ bcmos_module_id sender; /**< Sender module */
+ STAILQ_ENTRY(bcmos_msg) next; /**< Next message pointer */
+ void *data; /**< Message data pointer */
+ void *start; /**< Message data block start (for release) */
+ uint32_t size; /**< Message data size */
+ bcmos_msg_send_flags send_flags; /**< Flags the message was sent with */
+#define BCMOS_MSG_QUEUE_SIZE_UNLIMITED 0xFFFFFFFF /**< Unlimited queue */
+ void (*release)(bcmos_msg *); /**< Release callback */
+ void (*data_release)(bcmos_msg *); /**< Data release callback. Used when message is released to message pool */
+};
+
+/* Helper functions that pack / unpack message header for IPC */
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+
+/** Size of message header on the line for IPC */
+#define BCMOS_MSG_HDR_SIZE 8
+
+void bcmos_msg_hdr_pack(const bcmos_msg *msg, uint8_t *buf, uint32_t data_size);
+void bcmos_msg_hdr_unpack(const uint8_t *buf, bcmos_msg *msg);
+
+#endif
+
+/** Create message queue.
+ *
+ * This function can be called explicitly in "traditional" mode
+ * or implicitly by bcmos_module_create().
+ * \param[in,out] queue Queue control block
+ * \param[in] parm Queue parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_queue_create(bcmos_msg_queue *queue, const bcmos_msg_queue_parm *parm);
+
+/** Destroy queue
+ *
+ * \param[in] queue Queue handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_queue_destroy(bcmos_msg_queue *queue);
+
+/** Get queue info
+ *
+ * \param[in] queue Queue handle
+ * \param[out] info Queue information
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_queue_query(const bcmos_msg_queue *queue, bcmos_msg_queue_info *info);
+
+/** Message queue iterator
+ * \param[in] prev Previous queue. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_msg_queue_get_next(const bcmos_msg_queue **prev);
+
+/** Create message queue group.
+ *
+ * Queue group contains configurable number of queues. The queues are drained
+ * in strict priority. Priority 0 is the highest.
+ *
+ * \param[in,out] qgroup Queue group control block
+ * \param[in] parm Queue group parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_qgroup_create(bcmos_msg_qgroup *qgroup, const bcmos_msg_qgroup_parm *parm);
+
+/** Destroy queue group
+ *
+ * \param[in] qgroup Queue group handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_qgroup_destroy(bcmos_msg_qgroup *qgroup);
+
+/** Get queue group info
+ *
+ * \param[in] qgroup Queue group handle
+ * \param[out] info Queue group information
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_qgroup_query(const bcmos_msg_qgroup *qgroup, bcmos_msg_qgroup_info *info);
+
+/** Message queue group iterator
+ * \param[in] prev Previous queue group. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_msg_qgroup_get_next(const bcmos_msg_qgroup **prev);
+
+/** Send message to queue
+ *
+ * \param[in] queue Queue handle
+ * \param[in] msg Message
+ * \param[in] flags flags. Combination of \ref bcmos_msg_send_flags bits
+ *
+ * msg is released automatically regardless of bcmos_msg_send() outcome, unless
+ * BCMOS_MSG_SEND_NO_FREE_ON_ERROR flag is set.
+ *
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_send(bcmos_msg_queue *queue, bcmos_msg *msg, bcmos_msg_send_flags flags);
+
+/** Send message to module
+ *
+ * For module to be able to receive the message, it must be registered
+ * using bcmos_msg_register()
+ *
+ * \param[in] module_id Module id
+ * \param[in] msg Message. msg->handler must be set
+ * \param[in] flags flags. Combination of \ref bcmos_msg_send_flags bits
+ *
+ * msg is released automatically regardless of bcmos_msg_send_to_module() outcome, unless
+ * BCMOS_MSG_SEND_NO_FREE_ON_ERROR flag is set.
+ *
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_send_to_module(bcmos_module_id module_id, bcmos_msg *msg, bcmos_msg_send_flags flags);
+
+/** Send message to queue group
+ *
+ * \param[in] qgroup Queue group handle
+ * \param[in] msg Message
+ * \param[in] prty Message priority in range 0-nqueues_in_group-1.
+ * 0 priority is the highest. If MAX number of messages are already queues
+ * in the queue group, sending message can leave to discard of the head message
+ * queued at lower priority
+ * \param[in] flags BCMOS_MSG_SEND_AUTO_FREE or BCMOS_MSG_SEND_NO_FREE_ON_ERROR flag
+ *
+ *
+ * msg is released automatically regardless of bcmos_msg_send_to_qgroup() outcome, unless
+ * BCMOS_MSG_SEND_NO_FREE_ON_ERROR flag is set.
+ *
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_send_to_qgroup(bcmos_msg_qgroup *qgroup, bcmos_msg *msg, bcmos_qgroup_prty prty,
+ bcmos_msg_send_flags flags);
+
+/** Get message from the head of message queue
+ *
+ * The function can lead to the calling task being suspended for a period
+ * of time or indefinitely, until message is submitted to the queue.\n
+ * The function is only used in "traditional tasks" (see \ref system_model).
+ *
+ * \param[in] queue Queue handle
+ * \param[in] timeout timeout. can be 0, time in us or \ref BCMOS_WAIT_FOREVER
+ * \param[out] msg Message handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_recv(bcmos_msg_queue *queue, uint32_t timeout, bcmos_msg **msg);
+
+/** Get highest priority message from queue group
+ *
+ * The function can lead to the calling task being suspended for a period
+ * of time or indefinitely, until message is submitted to the queue group.\n
+ * The function is only used in "traditional tasks" (see \ref system_model).
+ *
+ * \param[in] qgroup Queue group handle
+ * \param[in] timeout timeout. can be 0, time in us or \ref BCMOS_WAIT_FOREVER
+ * \param[out] msg Message handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_recv_from_qgroup(bcmos_msg_qgroup *qgroup, uint32_t timeout, bcmos_msg **msg);
+
+/** Dispatch message. Send to module that registered for it.
+ *
+ * The message must be registered using bcmos_msg_register()
+ *
+ * This function should be used if the message sender doesn't know the target module and/or
+ * message handling callback.
+ *
+ * \param[in] msg Message handle
+ * \param[in] flags flags. Combination of \ref bcmos_msg_send_flags bits
+ *
+ * msg is released automatically regardless of bcmos_msg_dispatch() outcome, unless
+ * BCMOS_MSG_SEND_NO_FREE_ON_ERROR flag is set.
+ *
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_dispatch(bcmos_msg *msg, bcmos_msg_send_flags flags);
+
+/** Register message for "push-mode" delivery.
+ *
+ * When registered message is sent to the target module and
+ * the module's task wakes up, message handler is called in the module's context.
+ *
+ * \param[in] msg_type Message type
+ * \param[in] instance Message type instance
+ * \param[in] module_id Target module id
+ * \param[in] handler Message handler
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_register(bcmos_msg_id msg_type, bcmos_msg_instance instance,
+ bcmos_module_id module_id, F_bcmos_msg_handler handler);
+
+/** Un-register message registered by bcmos_msg_register()
+ *
+ * \param[in] msg_type Message type
+ * \param[in] instance Message type instance
+ * \param[in] module_id Target module id
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_unregister(bcmos_msg_id msg_type, bcmos_msg_instance instance,
+ bcmos_module_id module_id);
+
+/** Put the OS message infrastructure in "shutdown mode".
+ *
+ * When in shutdown mode, bcmos_msg_dispatch() will return BCM_ERR_OK instead of BCM_ERR_NOENT when a handler is not
+ * found for the message. Additionally, bcmos_msg_dispatch() becomes safe to call concurrently with
+ * bcmos_msg_unregister() (this is not true in normal operation).
+ *
+ * \param[in] shutdown_mode Whether or not to enable shutdown mode
+ */
+void bcmos_msg_shutdown_mode_set(bcmos_bool shutdown_mode);
+
+/** Gets whether or not the OS message infrastructure is currently in "shutdown mode".
+ * \returns BCMOS_TRUE if we are in shutdown mode, BCMOS_FALSE otherwise
+ */
+bcmos_bool bcmos_msg_shutdown_mode_get(void);
+
+/** Helper type for storing message types alongside their handlers. */
+typedef struct
+{
+ bcmos_msg_id msg_type;
+ F_bcmos_msg_handler handler;
+} bcmos_msg_id2handler;
+
+/** Message pool */
+typedef struct bcmos_msg_pool bcmos_msg_pool;
+
+/** Message pool parameters */
+typedef struct bcmos_msg_pool_parm
+{
+ const char *name; /**< Pool name */
+ uint32_t size; /**< Number of messages in the pool */
+ uint32_t data_size; /**< Message data size */
+ uint32_t flags; /**< TBD flags */
+ void (*data_release)(bcmos_msg *msg); /**< Optional data release callback. Called when message is released to the pool */
+} bcmos_msg_pool_parm;
+
+/** Message pool statistics */
+typedef bcmos_blk_pool_stat bcmos_msg_pool_stat;
+
+/** Message pool info */
+typedef struct bcmos_msg_pool_info
+{
+ bcmos_msg_pool_parm parm; /**< Pool parameters */
+ bcmos_msg_pool_stat stat; /**< Pool statistics */
+} bcmos_msg_pool_info;
+
+/** Create message pool
+ *
+ * Create pool containing pre-allocated messages with specified data size
+ * \param[in] pool Message pool handle
+ * \param[in] parm Message pool parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_pool_create(bcmos_msg_pool *pool, const bcmos_msg_pool_parm *parm);
+
+/** Destroy message pool
+ *
+ * All messages must be released to the pool before it can be destroyed.
+ *
+ * \param[in] pool Message pool handle
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_pool_destroy(bcmos_msg_pool *pool);
+
+/** Allocate message from pool
+ *
+ * The pool must be created using bcmos_pool_create()
+ * \param[in] pool Message pool handle
+ * \returns msg pointer or NULL if the pool is empty.
+ * "data" and "release" fields in the returned message are pre-set
+ * Once no longer needed, the message must be released using bcmos_msg_free()
+ */
+bcmos_msg *bcmos_msg_pool_alloc(bcmos_msg_pool *pool);
+
+/** Allocate message from pool and clear data
+ *
+ * The pool must be created using bcmos_pool_create()
+ * \param[in] pool Message pool handle
+ * \returns msg pointer or NULL if the pool is empty.
+ * "data" and "release" fields in the returned message are pre-set
+ * Once no longer needed, the message must be released using bcmos_msg_free()
+ */
+static inline bcmos_msg *bcmos_msg_pool_calloc(bcmos_msg_pool *pool)
+{
+ bcmos_msg *msg = bcmos_msg_pool_alloc(pool);
+ if (msg)
+ {
+ memset(msg->data, 0, msg->size);
+ }
+ return msg;
+}
+
+/** Get pool info
+ *
+ * The pool must be created using bcmos_pool_create()
+ * \param[in] pool Message pool handle
+ * \param[out] info Message pool info
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_msg_pool_query(const bcmos_msg_pool *pool, bcmos_msg_pool_info *info);
+
+/** Message pool iterator
+ * \param[in] prev Previous message pool. *prev==NULL - get first
+ * \return: BCM_ERR_OK, BCM_ERR_NOENT, BCM_ERR_NO_MORE
+ */
+bcmos_errno bcmos_msg_pool_get_next(const bcmos_msg_pool **prev);
+
+/** @} system_msg */
+
+/** \addtogroup system_module
+ * @{
+ */
+
+/** Max number of modules per task. Must be <= 32 */
+#define BCMOS_MAX_MODULES_PER_TASK 8
+
+/** Module parameters */
+typedef struct
+{
+ bcmos_msg_queue_parm qparm; /**< Message queue paramaters */
+ F_bcmos_module_init init; /**< Init callback */
+ F_bcmos_module_exit exit; /**< Exit callback */
+ long data; /**< Module context initial value. Also passed to init and exit callbacks */
+} bcmos_module_parm;
+
+/** Module control block */
+typedef struct bcmos_module bcmos_module;
+
+/** Register module
+ *
+ * \param[in] module_id Module id
+ * \param[in] task Owner task ID
+ * \param[in] parm Module parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_module_create(bcmos_module_id module_id, bcmos_task *task, bcmos_module_parm *parm);
+
+/** Un-register module
+ *
+ * \param[in] module_id Module id
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_module_destroy(bcmos_module_id module_id);
+
+/** Get current module id in the current task
+ *
+ * \returns module_id
+ */
+bcmos_module_id bcmos_module_current(void);
+
+/** Get module context
+ *
+ * Module context is initialized as module_parm.data and can be modified using
+ * bcmos_module_context_set()
+ *
+ * \param[in] module_id Module_id
+ * \returns context pointer set by bcmos_module_context_set() or
+ *
+ * NULL if module_id is invalid or context is not set.
+ */
+void *bcmos_module_context(bcmos_module_id module_id);
+
+/** Set module context
+ *
+ * Context is an arbitrary structure used to store module-specific data.
+ * Usually this function is called from module init() callback
+ *
+ * \param[in] module_id Module_id
+ * \param[in] context Module context pointer
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_module_context_set(bcmos_module_id module_id, void *context);
+
+/* module control blocks */
+extern bcmos_module *bcmos_modules[BCMOS_MODULE_ID__NUM_OF];
+
+static inline bcmos_module *_bcmos_module_get(bcmos_module_id module_id)
+{
+ bcmos_module *module = bcmos_modules[module_id];
+ if ((unsigned)module_id >= BCMOS_MODULE_ID__NUM_OF)
+ return NULL;
+ return module;
+}
+
+/** Query module
+ *
+ * \param[in] module_id Module_id
+ * \param[out] task Task that owns the module
+ * \param[out] info Module queue info
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_module_query(bcmos_module_id module_id, const bcmos_task **task, bcmos_msg_queue_info *info);
+
+/** @} system_module */
+
+/** \addtogroup system_event
+ * @{
+ */
+
+/** Registered event handler */
+typedef void (*F_bcmos_event_handler)(bcmos_event_id event_id, uint32_t active_bits);
+
+/** Event parameters */
+typedef struct
+{
+ const char *name; /**< Event set name */
+ bcmos_module_id module_id; /**< Module id. The module must be registered */
+ uint32_t mask; /**< Event bits module is interested in */
+ F_bcmos_event_handler handler; /**< Event handler. Called in module's context */
+ uint32_t flags; /**< TBD flags. E.g., inter-core */
+} bcmos_event_parm;
+
+/** Event control block */
+typedef struct bcmos_event bcmos_event;
+
+/** Create event set
+ *
+ * \param[in] event_id Event set id
+ * \param[in] parm Event parameters. Used in "integration" mode. NULL in "traditional" mode
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_event_create(bcmos_event_id event_id, bcmos_event_parm *parm);
+
+/** Destroy event set created by bcmos_event_create()
+ *
+ * \param[in] event_id Event set id
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_event_destroy(bcmos_event_id event_id);
+
+/** Raise event
+ *
+ * Raised event is delivered to module(s) that registered for it
+ * using bcmos_event_register() or to the task waiting for event
+ * using bcmos_event_recv()
+ *
+ * \param[in] event_id Event set id
+ * \param[in] active_bits Active bit mask
+ * \returns 0=OK or error code <0. Can only fail if event is not registered
+ */
+bcmos_errno bcmos_event_raise(bcmos_event_id event_id, uint32_t active_bits);
+
+/** Wait for event
+ *
+ * This function is used in "traditional" mode.\n
+ * The caller can block for a time or indefinitely
+ *
+ * \param[in] event_id Event set id
+ * \param[in] mask Interesting bits. The functions returns when
+ * - timeout expires
+ * - event with (active_bits & mask) != 0 is raised
+ * \param[in] timeout timeout. can be 0, time in us or \ref BCMOS_WAIT_FOREVER
+ * \param[out] active_bits active bits in the event set. valid only if the function returns 0
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_event_recv(bcmos_event_id event_id, uint32_t mask,
+ uint32_t timeout, uint32_t *active_bits);
+
+/* Event set array */
+extern bcmos_event *bcmos_events[BCMOS_EVENT_ID__NUM_OF];
+
+/* Get event givern the event id */
+static inline bcmos_event *_bcmos_event_get(bcmos_event_id event_id)
+{
+ bcmos_event *ev = bcmos_events[event_id];
+ if ((unsigned)event_id >= BCMOS_EVENT_ID__NUM_OF)
+ return NULL;
+ return ev;
+}
+
+/** @} system_event */
+
+/** \addtogroup system_timer
+ * @{
+ */
+
+/** Max timer duration (us) */
+#define BCMOS_MAX_TIMER_DURATION 0x80000000
+
+/** Timer control block */
+typedef struct bcmos_timer bcmos_timer;
+
+/** Timer handler completion code */
+typedef enum
+{
+ BCMOS_TIMER_OK, /**< Restart timer if periodic or keep stopped if not */
+ BCMOS_TIMER_STOP /**< Do not restart periodic timer */
+} bcmos_timer_rc;
+
+/** Timer handler
+ * \param[in] timer Expired timer handle
+ * \param[in] data User data supplied at timer creation time
+ * \returns \ref bcmos_timer_rc
+ */
+typedef bcmos_timer_rc (*F_bcmos_timer_handler)(bcmos_timer *timer, long data);
+
+typedef enum
+{
+ BCMOS_TIMER_PARM_FLAGS_URGENT = 0, /**< Default behavior. If the timer owner is set, timer expiration
+ will be delivered as an urgent message. */
+ BCMOS_TIMER_PARM_FLAGS_NON_URGENT = 1 << 0, /**< If the timer owner is set, timer expiration will be delivered as
+ a normal (non-urgent) message. */
+} bcmos_timer_parm_flags;
+
+/** Timer parameters */
+typedef struct
+{
+ const char *name; /**< Timer name */
+ bcmos_module_id owner; /**< Timer owner. If set, timer expiration is delivered to the module
+ as a message */
+ bcmos_bool periodic; /**< TRUE=periodic */
+ F_bcmos_timer_handler handler; /**< Timer handler. Called in context of owner module
+ if set or timer ISR if owner==BCMOS_MODULE_ID_NONE */
+ long data; /**< data to pass to the handler */
+ bcmos_timer_parm_flags flags; /**< Flags to change the behavior of the timer */
+} bcmos_timer_parm;
+
+#ifndef BCMOS_TIMESTAMP_INLINE
+
+/** Get current timestamp
+ * \returns the current system timestamp (us)
+ */
+uint32_t bcmos_timestamp(void);
+
+/** Get current 64 bit timestamp
+ * \returns the current system timestamp (us)
+ * \note There is no guarantee that all 64 bit carry information.
+ * However, it is guaranteed that the timestamp wraps around
+ * not oftener than every 50 days (ms resolution)
+ */
+uint64_t bcmos_timestamp64(void);
+
+#endif /* #ifndef BCMOS_TIMESTAMP_INLINE */
+
+/** Create timer
+ *
+ * \param[in,out] timer timer control block
+ * \param[in] parm timer parameters
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_timer_create(bcmos_timer *timer, bcmos_timer_parm *parm);
+
+/** Destroy timer
+ * The timer is stopped if running and destroyed
+ * \param[in] timer timer handle
+ */
+void bcmos_timer_destroy(bcmos_timer *timer);
+
+/** Set timer handler
+ *
+ * \param[in,out] timer timer control block
+ * \param[in] handler timer handler
+ * \param[in] data data to be passed to the handler
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_timer_handler_set(bcmos_timer *timer, F_bcmos_timer_handler handler, long data);
+
+/** (Re)start timer
+ * Stop timer if running and start it.
+ *
+ * \param[in] timer timer handle
+ * \param[in] delay delay in us
+ */
+void bcmos_timer_start(bcmos_timer *timer, uint32_t delay);
+
+/** Stop timer if running
+ *
+ * \param[in] timer timer handle
+ */
+void bcmos_timer_stop(bcmos_timer *timer);
+
+/** Suspend current task for a time
+ *
+ * \param[in] us sleep time (us)
+ */
+#ifndef BCMOS_USLEEP_INLINE
+void bcmos_usleep(uint32_t us);
+#endif /* #ifndef BCMOS_USLEEP_INLINE */
+
+/** @} system_timer */
+
+/** \addtogroup system_fastlock
+ * @{
+ */
+
+/** Fast lock control block */
+typedef struct bcmos_fastlock bcmos_fastlock;
+
+#ifndef BCMOS_FASTLOCK_INLINE
+
+/** Init fastlock
+ * \param[in, out] lock fast lock control block
+ * \param[in] flags flags - TBD. E.g., single core / SMP
+ */
+void bcmos_fastlock_init(bcmos_fastlock *lock, uint32_t flags);
+
+/** Take fast lock
+ * \param[in] lock fast lock
+ * \returns value of interrupt flags that should be used in unlock
+ */
+long bcmos_fastlock_lock(bcmos_fastlock *lock);
+
+/** Release fast lock
+ * \param[in] lock fast lock
+ * \param[in] flags interrupt flags
+ */
+void bcmos_fastlock_unlock(bcmos_fastlock *lock, long flags);
+
+#endif /* #ifndef BCMOS_FASTLOCK_INLINE */
+
+/** @} system_fastlock */
+
+/** \addtogroup system_mutex
+ * @{
+ */
+
+/** Mutex control block */
+typedef struct bcmos_mutex bcmos_mutex;
+
+#ifdef BCMOS_MUTEX_INLINE
+#define BCMOS_MUTEX_CREATE_DESTROY_INLINE
+#define BCMOS_MUTEX_LOCK_UNLOCK_INLINE
+#endif
+
+#ifndef BCMOS_MUTEX_CREATE_DESTROY_INLINE
+
+/** Create recursive mutex
+ * \param[in, out] mutex Mutex control block
+ * \param[in] flags flags - TBD. E.g., single core / SMP
+ * \param[in] name name of the mutex (if OS supports), NULL means it will be auto-generated
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_mutex_create(bcmos_mutex *mutex, uint32_t flags, const char *name);
+
+/** Destroy mutex
+ * \param[in] mutex Mutex control block
+ */
+void bcmos_mutex_destroy(bcmos_mutex *mutex);
+
+#endif /* BCMOS_MUTEX_CREATE_DESTROY_INLINE */
+
+
+#ifndef BCMOS_MUTEX_LOCK_UNLOCK_INLINE
+
+/** Lock mutex
+ * \param[in] mutex Mutex control block
+ */
+void bcmos_mutex_lock(bcmos_mutex *mutex);
+
+/** Release mutex
+ * \param[in] mutex Mutex control block
+ */
+void bcmos_mutex_unlock(bcmos_mutex *mutex);
+
+#endif /* #ifndef BCMOS_MUTEX_LOCK_UNLOCK_INLINE */
+
+/** @} system_mutex */
+
+/** \addtogroup system_sem
+ * @{
+ */
+
+/** Semaphore control block */
+typedef struct bcmos_sem bcmos_sem;
+
+#ifdef BCMOS_SEM_INLINE
+#define BCMOS_SEM_CREATE_DESTROY_INLINE
+#define BCMOS_SEM_WAIT_INLINE
+#define BCMOS_SEM_POST_INLINE
+#endif
+
+#ifndef BCMOS_SEM_CREATE_DESTROY_INLINE
+
+/** Create semaphore
+ * \param[in, out] sem semaphore control block
+ * \param[in] count initial value of semaphore counter
+ * \param[in] flags flags - TBD. E.g., single core / SMP
+ * \param[in] name name of the semaphore (if OS supports), NULL means it will be auto-generated
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_sem_create(bcmos_sem *sem, uint32_t count, uint32_t flags, const char *name);
+
+/** Destroy semaphore
+ * \param[in] sem semaphore control block
+ */
+void bcmos_sem_destroy(bcmos_sem *sem);
+
+#endif /* BCMOS_SEM_CREATE_DESTROY_INLINE */
+
+#ifndef BCMOS_SEM_WAIT_INLINE
+
+/** Decrement semaphore counter. Wait if the counter is 0
+ *
+ * \param[in] sem semaphore control block
+ * \param[in] timeout timeout. can be 0, time in us or \ref BCMOS_WAIT_FOREVER
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_sem_wait(bcmos_sem *sem, uint32_t timeout);
+
+#endif /* #ifndef BCMOS_SEM_WAIT_INLINE */
+
+#ifndef BCMOS_SEM_POST_INLINE
+/** Increment semaphore counter
+ * \param[in] sem semaphore control block
+ */
+void bcmos_sem_post(bcmos_sem *sem);
+
+#endif /* #ifndef BCMOS_SEM_POST_INLINE */
+
+/** @} system_sem */
+
+/*
+ * print support
+ */
+
+/** Print cloning/redirection mode */
+typedef enum
+{
+ BCMOS_PRINT_REDIRECT_MODE_NONE, /**< No cloning, redirection */
+ BCMOS_PRINT_REDIRECT_MODE_REDIRECT, /**< Redirect console output. Do not print on the serial console */
+ BCMOS_PRINT_REDIRECT_MODE_CLONE /**< Clone console output to redirection callback */
+} bcmos_print_redirect_mode;
+
+/** Print re-direction/cloning callback */
+typedef int (*bcmos_print_redirect_cb)(void *data, const char *format, va_list ap);
+
+/** Set up print redirection/cloning
+ * \param[in] mode redirection/cloning mode
+ * \param[in] cb redirection callback
+ * \param[in] data opaque data to be passed to cb
+ * \returns 0=OK or error <0
+ */
+bcmos_errno bcmos_print_redirect(bcmos_print_redirect_mode mode, bcmos_print_redirect_cb cb, void *data);
+
+/* Print on the console with optional cloning / redirection
+ * \param[in] format printf format
+ * \param[in] ap argument list
+ * \returns number of characters printed >= 0 or error < 0
+ */
+int bcmos_vprintf(const char *format, va_list ap);
+
+/* Print on the console with optional cloning / redirection
+ * \param[in] format printf format
+ * \returns number of characters printed >= 0 or error < 0
+ */
+int bcmos_printf(const char *format, ...);
+
+
+/** \addtogroup system_trace
+ * @{
+ */
+
+/** Trace level */
+typedef enum
+{
+ BCMOS_TRACE_LEVEL_NONE, /**< No trace output */
+ BCMOS_TRACE_LEVEL_ERROR, /**< Trace errors */
+ BCMOS_TRACE_LEVEL_WARNING, /**< Trace errors + warnings */
+ BCMOS_TRACE_LEVEL_INFO, /**< Trace errors + warnings + info */
+ BCMOS_TRACE_LEVEL_VERBOSE, /**< Trace errors + warnings + info + verbose info */
+ BCMOS_TRACE_LEVEL_DEBUG, /**< Trace everything */
+} bcmos_trace_level;
+
+extern bcmos_trace_level bcmos_sys_trace_level;
+
+#ifdef BCMOS_TRACE_PRINTF
+#define BCMOS_TRACE_INLINE
+#endif
+
+#ifndef BCMOS_TRACE_INLINE
+/** Print trace
+ *
+ * \param[in] level Record trace at level
+ * \param[in] format printf-like format
+ */
+void bcmos_trace(bcmos_trace_level level, const char *format, ...);
+#endif
+
+
+/* Print trace */
+#ifdef BCMOS_TRACE_PRINTF
+#define bcmos_trace(level, fmt, args...) bcmos_printf(fmt, ## args)
+#endif
+
+/** Set current trace level
+ * \param[in] level New trace level
+ * \returns old trace level
+ */
+static inline bcmos_trace_level bcmos_trace_level_set(bcmos_trace_level level)
+{
+ bcmos_trace_level old_level = bcmos_sys_trace_level;
+ bcmos_sys_trace_level = level;
+ return old_level;
+}
+
+/** Get current trace level
+ * \returns trace level
+ */
+static inline bcmos_trace_level bcmos_trace_level_get(void)
+{
+ return bcmos_sys_trace_level;
+}
+
+/** Print trace conditionally, depending on the current trace level
+ * \param[in] level Record trace at level
+ * \param[in] fmt printf-like format
+ * \param[in] args printf-like arguments
+ */
+#define BCMOS_TRACE(level, fmt, args...) \
+ do \
+ { \
+ if (level <= bcmos_sys_trace_level) \
+ bcmos_trace(level, "%s#%d> " fmt, __FUNCTION__, __LINE__, ## args); \
+ } while (0)
+
+/** Print error trace conditionally, depending on the current trace level
+ * \param[in] fmt printf-like format
+ * \param[in] args printf-like arguments
+ */
+
+extern f_bcmolt_sw_error_handler sw_error_handler;
+
+#define BCMOS_TRACE_ERR(fmt, args...) \
+ do \
+ { \
+ BCMOS_TRACE(BCMOS_TRACE_LEVEL_ERROR, "ERR: " fmt, ## args); \
+ if (sw_error_handler != NULL) \
+ { \
+ sw_error_handler(0xff, __FILE__, __LINE__); \
+ } \
+ _bcmos_backtrace(); \
+ } while (0)
+
+
+/** Print info trace conditionally, depending on the current trace level
+ * \param[in] fmt printf-like format
+ * \param[in] args printf-like arguments
+ */
+#define BCMOS_TRACE_INFO(fmt, args...) \
+ BCMOS_TRACE(BCMOS_TRACE_LEVEL_INFO, "INF: " fmt, ## args)
+
+/** Print verbose info trace conditionally, depending on the current trace level
+ * \param[in] fmt printf-like format
+ * \param[in] args printf-like arguments
+ */
+#define BCMOS_TRACE_VERBOSE(fmt, args...) \
+ BCMOS_TRACE(BCMOS_TRACE_LEVEL_VERBOSE, "VRB: " fmt, ## args)
+
+/** Print debug trace conditionally, depending on the current trace level
+ * \param[in] fmt printf-like format
+ * \param[in] args printf-like arguments
+ */
+#define BCMOS_TRACE_DEBUG(fmt, args...) \
+ BCMOS_TRACE(BCMOS_TRACE_LEVEL_DEBUG, "DBG: " fmt, ## args)
+
+/** Print trace conditionally based on return code and return
+ * \param[in] rc return code
+ * \param[in] fmt printf-like format
+ * \param[in] args printf-like arguments
+ * \returns rc
+ */
+#define BCMOS_TRACE_RETURN(rc, fmt, args...) \
+ do { \
+ if (rc) \
+ BCMOS_TRACE_ERR("status:%s :" fmt, bcmos_strerror(rc), ## args); \
+ else \
+ BCMOS_TRACE_INFO("success: " fmt, ## args); \
+ return rc; \
+ } while (0)
+
+#define BCMOS_TRACE_CHECK_RETURN(cond,rc,fmt,args...) \
+ do { \
+ if (cond) \
+ {\
+ BCMOS_TRACE_ERR( #cond ": status:%s :" fmt, bcmos_strerror(rc), ## args); \
+ return rc; \
+ }\
+ } while (0)
+#define BCMOS_CHECK_RETURN(cond,err,ret) \
+ do { \
+ if (cond) \
+ {\
+ BCMOS_TRACE_ERR( #cond ": status:%s\n", bcmos_strerror(err)); \
+ return ret; \
+ }\
+ } while (0)
+#define BCMOS_CHECK_RETURN_ERROR(cond,err) BCMOS_CHECK_RETURN(cond,err,err)
+#define BCMOS_RETURN_ON_ERROR(err) BCMOS_CHECK_RETURN(BCM_ERR_OK != err, err, /*this space intentionally left blank*/)
+#define BCMOS_RETURN_IF_ERROR(err) BCMOS_CHECK_RETURN_ERROR(BCM_ERR_OK != err, err)
+
+/** @} system_trace */
+
+/*
+ * Low level services
+ */
+
+/** \addtogroup system_buf
+ * @{
+ */
+
+/** Transport/network buffer */
+typedef struct bcmos_buf bcmos_buf;
+
+/** @} system_buf */
+
+/** Round a number up to the specified power of 2 */
+#define BCMOS_ROUND_UP(n, m) (((n) + (m) - 1) & ~((m) - 1))
+
+/** Round a number up to the nearest word multiple */
+#define BCMOS_ROUND_TO_WORD(n) BCMOS_ROUND_UP(n, sizeof(size_t))
+
+/* BCMOS_DIVIDE_ROUND_UP(integer_dividend / integer_divisor) == (integer_dividend + integer_divisor - 1) / integer_divisor */
+#define BCMOS_DIVIDE_ROUND_UP(n, m) (((n) + (m) - 1) / (m))
+
+#endif /* BCMOS_SYSTEM_COMMON_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_common2.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_common2.h
new file mode 100644
index 0000000..7317aac
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_common2.h
@@ -0,0 +1,676 @@
+/*
+<: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 BCMOS_COMMON2_H_
+#define BCMOS_COMMON2_H_
+
+#ifndef BCMOS_SYSTEM_H_
+#error Please do not include bcmos_common2.h directly. Include bcmos_system.h
+#endif
+
+#include "bcmos_endian.h"
+
+/* \addtogroup system
+ * @{
+ */
+
+#define BCMOS_MAX_NAME_LENGTH 48
+
+/** \addtogroup system_task
+ * @{
+ */
+
+/** Task control block */
+struct bcmos_task
+{
+ /* OS independent fields */
+ bcmos_task_parm parm; /**< Task creation parameters */
+ bcmos_module *modules[BCMOS_MAX_MODULES_PER_TASK];
+ uint32_t active_modules; /**< Bitmask of modules for which events are pending */
+ bcmos_sem active_sem; /**< Semaphore used to wait for module activity */
+ bcmos_fastlock active_lock; /**< Lock protecting active_modules */
+ bcmos_module_id current_module; /**< Current module */
+ bcmos_bool destroy_request; /**< Task destroy request pending */
+ bcmos_bool destroyed; /**< Set by task handler before it terminates */
+ STAILQ_ENTRY(bcmos_task) list; /**< Next task pointer */
+ char name[BCMOS_MAX_NAME_LENGTH]; /**< Task name */
+ bcmos_sys_task sys_task; /**< OS-specific task extension */
+ uint32_t magic; /* magic number */
+#define BCMOS_TASK_MAGIC (('t' << 24) | ('a' << 16) | ('s' << 8) | 'k')
+#define BCMOS_TASK_MAGIC_DESTROYED (('t' << 24) | ('a' << 16) | ('s' << 8) | '~')
+};
+
+/** \addtogroup system_mem
+ * @{
+ */
+
+#ifndef BCMOS_CALLOC_INLINE
+
+/** Allocate memory from the main heap and clear it
+ * \ingroup system_heap
+ * \param[in] size
+ * \returns memory block pointer or NULL
+ */
+static inline void *bcmos_calloc(uint32_t size)
+{
+ void *ptr = bcmos_alloc(size);
+ if (ptr)
+ memset(ptr, 0, size);
+ return ptr;
+}
+#endif /* #ifndef BCMOS_CALLOC_INLINE */
+
+#ifndef BCMOS_DMA_ALLOC_FREE_INLINE
+
+/** Allocate DMA-able memory
+ * \param[in] device Device id
+ * \param[in] size Block size (bytes)
+ * \returns memory block pointer or NULL
+ */
+void *bcmos_dma_alloc(uint8_t device, uint32_t size);
+
+/** Release DMA-able memory
+ * \param[in] device Device id
+ * \param[in] ptr Block pointer
+ */
+void bcmos_dma_free(uint8_t device, void *ptr);
+
+#endif /* #ifndef BCMOS_DMA_ALLOC_FREE_INLINE */
+
+#ifndef BCMOS_VIRT_TO_PHYS_INLINE
+
+/** Convert virtual address to physical address
+ *
+ * \param[in] va Virtual address
+ * \returns - physical address va is mapped to
+ */
+unsigned long bcmos_virt_to_phys(void *va);
+
+#endif /* #ifndef BCMOS_VIRT_TO_PHYS_INLINE */
+
+/** @} */
+
+/** \addtogroup blk_pool
+ * @{
+ */
+
+/* Memory block header */
+typedef struct bcmos_memblk bcmos_memblk;
+
+/* Memory block list */
+typedef STAILQ_HEAD(, bcmos_memblk) bcmos_memblk_list;
+
+/* Block memory pool control block */
+struct bcmos_blk_pool
+{
+ bcmos_fastlock lock; /**< Pool protection lock */
+ bcmos_memblk_list free_list;/**< Free block list */
+ bcmos_blk_pool_parm parm; /**< Pool parameters */
+ bcmos_blk_pool_stat stat; /**< Pool statistics */
+ void *start; /**< Pool start pointer */
+ char name[BCMOS_MAX_NAME_LENGTH]; /**< Pool name */
+ uint32_t magic; /**< magic number */
+#define BCMOS_BLK_POOL_VALID (('b'<<24) | ('l' << 16) | ('p' << 8) | 'o')
+#define BCMOS_BLK_POOL_DELETED (('b'<<24) | ('l' << 16) | ('p' << 8) | '~')
+ STAILQ_ENTRY(bcmos_blk_pool) list; /* Pool list */
+};
+
+/* Total memory occupied by all block pools */
+extern uint32_t bcmos_total_blk_pool_size;
+
+/** @} blk_pool */
+
+/** \addtogroup system_msg
+ * @{
+ */
+
+/** Release message
+ * \param[in] msg Message handle
+ */
+static inline void bcmos_msg_free(bcmos_msg *msg)
+{
+ if (msg->release)
+ {
+ msg->release(msg);
+ }
+ else
+ {
+ bcmos_free(msg);
+ }
+}
+
+typedef STAILQ_HEAD(, bcmos_msg) bcmos_msg_list;
+
+/** Simple Message queue control block.
+ * Simple message queue doesn't support waiting on.
+ * It is used in module queue mechanisms.
+ */
+typedef struct bcmos_msg_queue_nw
+{
+ bcmos_msg_queue_parm parm; /**< Queue parameters */
+ bcmos_msg_queue_stat stat; /**< Queue statistics */
+ bcmos_fastlock lock; /**< Queue protection lock */
+ bcmos_msg_list msgl; /**< Message list */
+ bcmos_msg_list msgl_urg; /**< Urgent message list */
+ uint32_t flags; /**< Queue flags */
+} bcmos_msg_queue_nw;
+
+/** Message queue control block */
+struct bcmos_msg_queue
+{
+ bcmos_msg_queue_nw q; /**< Queue control block */
+ bcmos_sem m; /**< Mutex to suspend waiting task on */
+ bcmos_bool is_waiting; /**< TRUE if task is waiting on queue */
+ char name[BCMOS_MAX_NAME_LENGTH]; /**< Queue name */
+#ifdef BCMOS_MSG_QUEUE_REMOTE_SUPPORT
+ long ep; /**< Endpoint handle (e.g., socket) */
+ void *ep_extra_data; /**< Extra data - depending on ep type */
+ uint32_t ep_extra_data_size;/**< Extra data size */
+ uint8_t *send_buf; /**< Send buffer */
+ uint8_t *recv_buf; /**< Receive buffer */
+ bcmos_mutex send_lock; /**< Mutex that protects send_buf */
+#endif
+ uint32_t magic; /**< magic number */
+#define BCMOS_MSG_QUEUE_VALID (('m'<<24) | ('q' << 16) | ('u' << 8) | 'e')
+#define BCMOS_MSG_QUEUE_DELETED (('m'<<24) | ('q' << 16) | ('u' << 8) | '~')
+ STAILQ_ENTRY(bcmos_msg_queue) list; /* Queue list */
+};
+
+/** Message queue group control block */
+struct bcmos_msg_qgroup
+{
+ bcmos_msg_qgroup_parm parm; /**< Queue group parameters */
+ bcmos_msg_list *msgl; /**< Array of parm.nqueues message lists */
+ bcmos_msg_queue_stat stat; /**< Queue group statistics */
+ bcmos_sem m; /**< Mutex to suspend waiting task on */
+ bcmos_fastlock lock; /**< Queue group protection lock */
+ uint32_t active_mask; /**< Bitmask of queues containing messages */
+ bcmos_bool is_waiting; /**< TRUE if task is waiting on queue group */
+ char name[BCMOS_MAX_NAME_LENGTH]; /**< Queue group name */
+ uint32_t magic; /**< magic number */
+#define BCMOS_MSG_QGROUP_VALID (('m'<<24) | ('q' << 16) | ('g' << 8) | 'r')
+#define BCMOS_MSG_QGROUP_DELETED (('m'<<24) | ('q' << 16) | ('g' << 8) | '~')
+ STAILQ_ENTRY(bcmos_msg_qgroup) list; /* Queue group list */
+};
+
+/** Message pool control block */
+struct bcmos_msg_pool
+{
+ bcmos_blk_pool blk_pool; /**< Underlying block memory pool */
+ bcmos_msg_pool_parm parm; /**< Pool parameters */
+};
+
+/* Total memory occupied by all message pools */
+extern uint32_t bcmos_total_msg_pool_size;
+
+/** @} system_msg */
+
+/** \addtogroup system_timer */
+
+/* Timer precision. Must be a multiple of 2.
+ * Timed expiration timestamp is rounded up to the nearest multiple of timer precision
+ */
+#define BCMOS_TIMER_PRECISION_US 32
+#if (BCMOS_TIMER_PRECISION_US & (BCMOS_TIMER_PRECISION_US - 1))
+ #error BCMOS_TIMER_PRECISION_US must be a multiple of 2
+#endif
+
+/* There are 2 timer implementations
+ * - DLIST-based - works well when most of active timers have the same duration
+ * - RB-tree based - more expensive in simple case, but scales better for large number of timers
+ * with arbitrary durations
+ */
+#define BCMOS_TIMER_RB_TREE
+
+/** Timer control block */
+struct bcmos_timer
+{
+ bcmos_msg msg; /**< Timer message */
+ bcmos_timer_parm parm; /**< Timer parameters */
+ F_bcmos_timer_handler handler; /**< Timer handler */
+ uint32_t period; /**< Timer period (us) if periodic */
+ uint32_t expire_at; /**< Timestamp when timer should expire */
+ uint32_t flags; /* Internal flags */
+#define BCMOS_TIMER_FLAG_RUNNING 0x00000001 /* Timer is running */
+#define BCMOS_TIMER_FLAG_EXPIRED 0x00000002 /* Timer has expired, but not yet handled */
+#define BCMOS_TIMER_FLAG_ACTIVE (BCMOS_TIMER_FLAG_RUNNING | BCMOS_TIMER_FLAG_EXPIRED)
+#define BCMOS_TIMER_FLAG_VALID 0x00000004
+ bcmos_msg_queue_nw *queue; /**< Queue expired timer is on */
+ bcmos_task *task; /**< Task that executes timer handler */
+#ifdef BCMOS_TIMER_RB_TREE
+ RB_ENTRY(bcmos_timer) entry; /**< Timer pool entry */
+#else
+ TAILQ_ENTRY(bcmos_timer) entry;
+#endif
+};
+
+/** Check if timer is running
+ * \param[in] timer Timer handle
+ * \returns TRUE if timer is running
+ */
+static inline bcmos_bool bcmos_timer_is_running(const bcmos_timer *timer)
+{
+ bcmos_bool running = ((timer->flags & BCMOS_TIMER_FLAG_RUNNING) != 0) ||
+ (timer->parm.periodic && ((timer->flags & BCMOS_TIMER_FLAG_EXPIRED) != 0));
+ return running;
+}
+
+static inline bcmos_timer *_bcmos_msg_to_timer(bcmos_msg *msg)
+{
+ BUG_ON(msg->type != BCMOS_MSG_ID_INTERNAL_TIMER);
+ return (bcmos_timer *)msg;
+}
+
+/** @} */
+
+/** \addtogroup system_module
+ * @{
+ */
+
+/** Module control block */
+struct bcmos_module
+{
+ bcmos_module_parm parm; /**< Module parameters */
+ bcmos_module_id id; /**< Module id */
+ int idx; /**< Module index in task control block */
+ bcmos_msg_queue_nw msgq; /**< Message queue */
+ bcmos_task *my_task; /**< Task the module is associated with */
+ void *context; /**< User-defined context */
+ char name[BCMOS_MAX_NAME_LENGTH]; /**< Module name */
+};
+
+/** @} system_module */
+
+/** \addtogroup system_event
+ * @{
+ */
+
+/** Event control block */
+struct bcmos_event
+{
+ bcmos_msg msg; /**< Message header. Used to deliver event to module's queue */
+ bcmos_event_id id; /**< Event set id */
+ bcmos_event_parm parm; /**< Event parameters */
+ bcmos_fastlock lock; /**< Protects event control block */
+ uint32_t active_bits; /**< Active event bits */
+
+ bcmos_sem m; /**< Mutex to suspend task on. Traditional mode only */
+ bcmos_bool is_waiting; /**< TRUE if task is waiting for event */
+ char name[BCMOS_MAX_NAME_LENGTH]; /**< Event name */
+};
+
+
+static inline bcmos_event *_bcmos_msg_to_event(bcmos_msg *msg)
+{
+ BUG_ON(msg->type != BCMOS_MSG_ID_INTERNAL_EVENT);
+ return (bcmos_event *)msg;
+}
+
+/*
+ * Low level services
+ */
+
+/** \addtogroup system_buf
+ * @{
+ */
+
+#ifndef BCMOS_BUF_OS_SPECIFIC
+#define BCMOS_BUF_DATA_INLINE
+#endif
+
+#ifdef BCMOS_BUF_INLINE
+#define BCMOS_BUF_ALLOC_FREE_INLINE
+#define BCMOS_BUF_DATA_INLINE
+#endif
+
+#ifndef BCMOS_BUF_DATA_GUARD
+#define BCMOS_BUF_DATA_GUARD 0
+#endif
+
+#ifndef BCMOS_BUF_DATA_ALIGNMENT
+#define BCMOS_BUF_DATA_ALIGNMENT 64
+#endif
+
+#ifndef BCMOS_BUF_ALLOC_FREE_INLINE
+
+/** Allocate transport buffer.
+ * The buffer can accommodate up to size bytes of data.
+ * In addition it reserves BCMTR_BUF_EXTRA_HEADROOM headroom bytes
+ * for extra headers.
+ *
+ * \param[in] size Data size
+ * \returns buffer pointer or NULL if no memory
+ */
+bcmos_buf *bcmos_buf_alloc(uint32_t size);
+
+ /** Release transport buffer allocated by bcmos_buf_alloc()
+ *
+ * \param[in] buf Buffer to be released
+ */
+void bcmos_buf_free(bcmos_buf *buf);
+
+#endif /* BCMOS_BUF_ALLOC_FREE_INLINE */
+
+#ifndef BCMOS_BUF_DATA_INLINE
+
+/** Get data length
+ *
+ * \param[in] buf Buffer
+ * \returns data length
+ */
+uint32_t bcmos_buf_length(bcmos_buf *buf);
+
+/** Set data length
+ *
+ * \param[in] buf Buffer
+ * \param[in] length Data length
+ * \returns 0=OK, or BCM_ERR_OVERFLOW if length exceeds size
+ */
+bcmos_errno bcmos_buf_length_set(bcmos_buf *buf, uint32_t length);
+
+/** Get buffer data pointer.
+ * \param[in] buf Buffer
+ * \returns data pointer
+ */
+uint8_t *bcmos_buf_data(bcmos_buf *buf);
+
+#endif /* BCMOS_BUF_DATA_INLINE */
+
+#ifndef BCMOS_BUF_OS_SPECIFIC
+
+#ifndef unlikely
+#define unlikely(x) (x)
+#endif
+
+/* Generic (not os-specific) sysb implementation */
+
+/*
+ * Network / transport buffer
+ */
+
+
+/* Memory block list */
+typedef STAILQ_HEAD(, bcmos_buf) bcmos_buf_list_head;
+
+typedef struct
+{
+ bcmos_buf_list_head head; /**< Buffer list head */
+} bcmos_buf_queue;
+
+/* System buffer. We probably can use mbuf as well. */
+struct bcmos_buf
+{
+ uint8_t *start;
+ uint8_t *data;
+ bcmos_blk_pool *pool;
+ uint32_t size;
+ uint32_t len;
+ STAILQ_ENTRY(bcmos_buf) list; /**< Next buffer pointer */
+ uint8_t channel;
+};
+
+
+#ifndef BCMTR_BUF_EXTRA_HEADROOM
+#define BCMTR_BUF_EXTRA_HEADROOM 0
+#endif
+
+
+/** Initialize buffer queue
+ * \param[in] q Buffer queue
+ */
+static inline void bcmos_buf_queue_init(bcmos_buf_queue *q)
+{
+ STAILQ_INIT(&q->head);
+}
+
+/* Check if buffer queue is empty
+ * \param[in] q Buffer queue
+ * \returns TRUE if the queue is empty
+ */
+static inline bcmos_bool bcmos_buf_queue_is_empty(bcmos_buf_queue *q)
+{
+ return (bcmos_bool)STAILQ_EMPTY(&q->head);
+}
+
+/** Enqueue buffer
+ *
+ * Must be called under lock, e.g., q->lock
+ *
+ * \param[in] q Buffer queue
+ * \param[in] buf Buffer
+ */
+static inline void bcmos_buf_queue_put(bcmos_buf_queue *q, bcmos_buf *buf)
+{
+ STAILQ_INSERT_TAIL(&q->head, buf, list);
+}
+
+/* Dequeue buffer
+ *
+ * Must be called under lock, e.g., q->lock
+ *
+ * Remove and return the 1st queued buffer.
+ * \param[in] q Buffer queue
+ * \returns the buffer pointer
+ */
+static inline bcmos_buf *bcmos_buf_queue_get(bcmos_buf_queue *q)
+{
+ bcmos_buf *buf;
+ buf = STAILQ_FIRST(&q->head);
+ if (buf)
+ STAILQ_REMOVE_HEAD(&q->head, list);
+ return buf;
+}
+
+/* Peek into queue and return the 1st buffer without dequeing it
+ *
+ * Must be called under lock, e.g., q->lock
+ * \param[in] q Buffer queue
+ * \returns the buffer pointer
+ */
+static inline bcmos_buf *bcmos_buf_queue_peek(bcmos_buf_queue *q)
+{
+ return STAILQ_FIRST(&q->head);
+}
+
+/* Initialize buffer */
+static inline bcmos_buf *bcmos_buf_init(bcmos_buf *buf, uint8_t *start,
+ uint8_t *data, uint32_t size, uint32_t len)
+{
+ BUG_ON((void *)(buf +1) != start);
+ buf->start = start;
+ buf->data = data;
+ buf->size = size;
+ buf->len = len;
+ buf->pool = NULL;
+ return buf;
+}
+
+/* Get data length */
+static inline uint32_t bcmos_buf_length(bcmos_buf *buf)
+{
+ return buf->len;
+}
+
+/* Set data length */
+static inline bcmos_errno bcmos_buf_length_set(bcmos_buf *buf, uint32_t length)
+{
+ if (unlikely(length > buf->size - (buf->data - buf->start)))
+ {
+ BCMOS_TRACE_ERR("!!!%s: length=%u size=%u data=%p start=%p data-start=%u\n",
+ __FUNCTION__, length, buf->size, buf->data, buf->start, (uint32_t)(buf->data - buf->start));
+ return BCM_ERR_OVERFLOW;
+ }
+ buf->len = length;
+ return BCM_ERR_OK;
+}
+
+/* Get buffer data pointer. */
+static inline uint8_t *bcmos_buf_data(bcmos_buf *buf)
+{
+ return buf->data;
+}
+
+/* Get buffer channel. */
+static inline uint8_t bcmos_buf_channel(bcmos_buf *buf)
+{
+ return buf->channel;
+}
+
+/* Set buffer channel. */
+static inline void bcmos_buf_channel_set(bcmos_buf *buf, uint8_t channel)
+{
+ buf->channel = channel;
+}
+
+#endif /* #ifndef BCMOS_BUF_OS_SPECIFIC */
+
+/** @} bcmos_buf */
+
+/** \addtogroup system_cache
+ * @{
+ */
+
+#ifndef BCMOS_CACHE_INLINE
+
+/** Invalidate address area in data cache. Dirty cache lines content is discarded.
+ * \param[in] start Address area start
+ * \param[in] size Address area size
+ */
+void bcmos_dcache_inv(void *start, uint32_t size);
+
+/** Flush address area in data cache. Dirty cache lines are committed to memory.
+ * \param[in] start Address area start
+ * \param[in] size Address area size
+ */
+void bcmos_dcache_flush(void *start, uint32_t size);
+
+#endif /* BCMOS_CACHE_INLINE */
+
+/** Prepare for DMA write.
+ * On h/w platforms that support DMA-cache coherency, this function should
+ * perform write barrier.
+ * On platforms that don't support DMA cache coherency this function should
+ * flush the relevant dcache area
+ *
+ * \param[in] start DMA buffer start address
+ * \param[in] size DMA buffer size
+ */
+static inline void bcmos_prepare_for_dma_write(void *start, uint32_t size)
+{
+#ifdef BCMOS_DMA_CACHE_COHERENCY
+ bcmos_barrier();
+#else
+ bcmos_dcache_flush(start, size);
+#endif
+}
+
+/** Prepare for DMA read.
+ * On h/w platforms that support DMA-cache coherency, this function should
+ * perform write barrier.
+ * On platforms that don't support DMA cache coherency this function should
+ * invalidate the relevant dcache area
+ *
+ * \param[in] start DMA buffer start address
+ * \param[in] size DMA buffer size
+ */
+static inline void bcmos_prepare_for_dma_read(void *start, uint32_t size)
+{
+#ifdef BCMOS_DMA_CACHE_COHERENCY
+ bcmos_barrier();
+#else
+ bcmos_dcache_inv(start, size);
+#endif
+}
+
+/** @} system_cache */
+
+/** \addtogroup system_interrupt
+ * @{
+ */
+
+#ifdef BCMOS_INTERRUPT_INLINE
+#define BCMOS_INTERRUPT_CONNECT_DISCONNECT_INLINE
+#define BCMOS_INTERRUPT_ENABLE_DISABLE_INLINE
+#endif
+
+#ifndef BCMOS_INTERRUPT_CONNECT_DISCONNECT_INLINE
+/** Connect system interrupt
+ * \param[in] irq IRQ number
+ * \param[in] cpu CPU number (for SMP)
+ * \param[in] flags IRQ flags
+ * \param[in] isr ISR
+ * \param[in] name device name
+ * \param[in] priv Private cookie
+ * \returns 0=OK, <0- error
+ */
+int bcmos_int_connect(int irq, int cpu, int flags,
+ int (*isr)(int irq, void *priv), const char *name, void *priv);
+
+/** Disconnect system interrupt
+ * \param[in] irq IRQ number
+ * \param[in] priv Private cookie passed in bcmos_int_connect()
+ * \returns 0=OK, <0- error
+ */
+void bcmos_int_disconnect(int irq, void *priv);
+#endif
+
+#ifndef BCMOS_INTERRUPT_ENABLE_DISABLE_INLINE
+/** Unmask IRQ
+ * \param[in] irq IRQ
+ */
+void bcmos_int_enable(int irq);
+
+/** Mask IRQ
+ * \param[in] irq IRQ
+ */
+void bcmos_int_disable(int irq);
+#endif
+
+/** @} */
+
+/* Get char, put char support */
+#ifndef BCMOS_GETCHAR_INLINE
+static inline int bcmos_getchar(void)
+{
+ return getchar();
+}
+#endif
+
+#ifndef BCMOS_PUTCHAR_INLINE
+void bcmos_putchar(int c);
+#endif
+
+#ifndef BCMOS_SEM_POST_IS_ALLOWED_INLINE
+static inline bcmos_bool bcmos_sem_post_is_allowed(void)
+{
+ return BCMOS_TRUE;
+}
+#endif
+
+#endif /* BCMOS_COMMON2_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_endian.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_endian.h
new file mode 100644
index 0000000..ece41dc
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_endian.h
@@ -0,0 +1,130 @@
+/*
+<: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 BCMOS_ENDIAN_H_
+#define BCMOS_ENDIAN_H_
+
+#ifndef BCMOS_SYSTEM_H_
+#error Please do not include bcmos_endian.h directly. Include bcmos_system.h
+#endif
+
+
+
+/** @} system_event */
+
+/** \addtogroup system_endian
+ * @{
+ */
+#ifndef BCMOS_ARCH_ENDIAN_SWAP
+
+/** Swaps the endianness of a 16-bit integer
+ * \param[in] n the original number
+ * \return number with swapped endianness
+ */
+static inline uint16_t bcmos_endian_swap_u16(uint16_t n)
+{
+ return ((n << 8 ) & 0xFF00U)|((n >> 8) & 0x00FFU);
+}
+
+/** Swaps the endianness of a 24-bit integer
+ * \param[in] n the original number
+ * \return number with swapped endianness
+ */
+static inline uint24_t bcmos_endian_swap_u24(uint24_t n)
+{
+ return (uint24_t){ .u8 = { n.u8[2], n.u8[1], n.u8[0] } };
+}
+
+/** Swaps the endianness of a 32-bit integer
+ * \param[in] n the original number
+ * \return number with swapped endianness
+ */
+static inline uint32_t bcmos_endian_swap_u32(uint32_t n)
+{
+ return ((n << 24) & 0xFF000000U)|((n << 8 ) & 0x00FF0000U)|((n >> 8) & 0x0000FF00U)|((n >> 24) & 0x000000FFU);
+}
+
+/** Swaps the endianness of a 64-bit integer
+ * \param[in] n the original number
+ * \return number with swapped endianness
+ */
+static inline uint64_t bcmos_endian_swap_u64(uint64_t n)
+{
+ return (((uint64_t)bcmos_endian_swap_u32(n & 0xFFFFFFFFU) << 32) | bcmos_endian_swap_u32((n >> 32) & 0xFFFFFFFFU));
+}
+
+#endif /* BCMOS_ARCH_ENDIAN_SWAP */
+
+#if (BCM_CPU_ENDIAN == BCMOS_ENDIAN_BIG)
+
+#define BCMOS_ENDIAN_CPU_TO_BIG_U16(n) (n)
+#define BCMOS_ENDIAN_CPU_TO_BIG_U24(n) (n)
+#define BCMOS_ENDIAN_CPU_TO_BIG_U32(n) (n)
+#define BCMOS_ENDIAN_CPU_TO_BIG_U64(n) (n)
+#define BCMOS_ENDIAN_BIG_TO_CPU_U16(n) (n)
+#define BCMOS_ENDIAN_BIG_TO_CPU_U24(n) (n)
+#define BCMOS_ENDIAN_BIG_TO_CPU_U32(n) (n)
+#define BCMOS_ENDIAN_BIG_TO_CPU_U64(n) (n)
+
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U16(n) (bcmos_endian_swap_u16(n))
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U24(n) (bcmos_endian_swap_u24(n))
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U32(n) (bcmos_endian_swap_u32(n))
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U64(n) (bcmos_endian_swap_u64(n))
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U16(n) (bcmos_endian_swap_u16(n))
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U24(n) (bcmos_endian_swap_u24(n))
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U32(n) (bcmos_endian_swap_u32(n))
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U64(n) (bcmos_endian_swap_u64(n))
+
+#elif (BCM_CPU_ENDIAN == BCMOS_ENDIAN_LITTLE)
+
+#define BCMOS_ENDIAN_CPU_TO_BIG_U16(n) (bcmos_endian_swap_u16(n))
+#define BCMOS_ENDIAN_CPU_TO_BIG_U24(n) (bcmos_endian_swap_u24(n))
+#define BCMOS_ENDIAN_CPU_TO_BIG_U32(n) (bcmos_endian_swap_u32(n))
+#define BCMOS_ENDIAN_CPU_TO_BIG_U64(n) (bcmos_endian_swap_u64(n))
+#define BCMOS_ENDIAN_BIG_TO_CPU_U16(n) (bcmos_endian_swap_u16(n))
+#define BCMOS_ENDIAN_BIG_TO_CPU_U24(n) (bcmos_endian_swap_u24(n))
+#define BCMOS_ENDIAN_BIG_TO_CPU_U32(n) (bcmos_endian_swap_u32(n))
+#define BCMOS_ENDIAN_BIG_TO_CPU_U64(n) (bcmos_endian_swap_u64(n))
+
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U16(n) (n)
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U24(n) (n)
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U32(n) (n)
+#define BCMOS_ENDIAN_CPU_TO_LITTLE_U64(n) (n)
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U16(n) (n)
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U24(n) (n)
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U32(n) (n)
+#define BCMOS_ENDIAN_LITTLE_TO_CPU_U64(n) (n)
+
+#else
+#error BCM_CPU_ENDIAN must be BCMOS_ENDIAN_BIG or _LITTLE
+#endif
+
+/** @} system_endian */
+
+#endif /* BCMOS_COMMON2_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_errno.c b/bcm68620_release/release/host_customized/os_abstraction/bcmos_errno.c
new file mode 100644
index 0000000..a2a0ff8
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_errno.c
@@ -0,0 +1,86 @@
+/*
+<: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"
+
+/* Map error code to error string */
+const char *bcmos_strerror(bcmos_errno err)
+{
+ static const char *errstr[] = {
+ [-BCM_ERR_OK] = "OK",
+ [-BCM_ERR_IN_PROGRESS] = "In progress",
+ [-BCM_ERR_PARM] = "Error in parameters",
+ [-BCM_ERR_NOMEM] = "No memory",
+ [-BCM_ERR_NORES] = "No resources",
+ [-BCM_ERR_INTERNAL] = "Internal error",
+ [-BCM_ERR_NOENT] = "Entry doesn't exist",
+ [-BCM_ERR_NODEV] = "Device doesn't exist",
+ [-BCM_ERR_ALREADY] = "Entry already exists",
+ [-BCM_ERR_RANGE] = "Out of range",
+ [-BCM_ERR_PERM] = "No permission to perform an operation",
+ [-BCM_ERR_NOT_SUPPORTED] = "Operation is not supported",
+ [-BCM_ERR_PARSE] = "Parsing error",
+ [-BCM_ERR_INVALID_OP] = "Invalid operation",
+ [-BCM_ERR_IO] = "I/O error",
+ [-BCM_ERR_STATE] = "Object is in bad state",
+ [-BCM_ERR_DELETED] = "Object is deleted",
+ [-BCM_ERR_TOO_MANY] = "Too many objects",
+ [-BCM_ERR_NO_MORE] = "No more entries",
+ [-BCM_ERR_OVERFLOW] = "Buffer overflow",
+ [-BCM_ERR_COMM_FAIL] = "Communication failure",
+ [-BCM_ERR_NOT_CONNECTED] = "No connection with the target system",
+ [-BCM_ERR_SYSCALL_ERR] = "System call returned error",
+ [-BCM_ERR_MSG_ERROR] = "Received message is insane",
+ [-BCM_ERR_TOO_MANY_REQS] = "Too many outstanding requests",
+ [-BCM_ERR_TIMEOUT] = "Operation timed out",
+ [-BCM_ERR_TOO_MANY_FRAGS] = "Too many fragments",
+ [-BCM_ERR_NULL] = "Got NULL pointer",
+ [-BCM_ERR_READ_ONLY] = "Attempt to set read-only parameter",
+ [-BCM_ERR_ONU_ERR_RESP] = "ONU returned an error response",
+ [-BCM_ERR_MANDATORY_PARM_IS_MISSING] = "Mandatory parameter is missing",
+ [-BCM_ERR_KEY_RANGE] = "Key field out of range",
+ [-BCM_ERR_QUEUE_EMPTY] = "Rx of PCIe empty",
+ [-BCM_ERR_QUEUE_FULL] = "Tx of PCIe full",
+ [-BCM_ERR_TOO_LONG] = "Processing is taking too long, but will finish eventually",
+ [-BCM_ERR_INSUFFICIENT_LIST_MEM] = "Insufficient list memory provided",
+
+ [-BCM_ERR_OUT_OF_SYNC] = "Sequence number or operation step was out of sync",
+ [-BCM_ERR_CHECKSUM] = "Checksum error",
+ [-BCM_ERR_IMAGE_TYPE] = "Unsupported file/image type",
+ [-BCM_ERR_INCOMPLETE_TERMINATION] = "Incomplete premature termination",
+ };
+ static const char *unknown = "*unknown*";
+
+ if ((unsigned)(-err) >= sizeof(errstr)/sizeof(errstr[0]) || !errstr[-err])
+ return unknown;
+ return errstr[-err];
+}
+
+#ifdef __KERNEL__
+EXPORT_SYMBOL(bcmos_strerror);
+#endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_errno.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_errno.h
new file mode 100644
index 0000000..f5e892a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_errno.h
@@ -0,0 +1,91 @@
+/*
+<: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 BCMOS_ERRNO_H_
+#define BCMOS_ERRNO_H_
+
+/** \defgroup system_errno Error Codes
+ * @{
+ */
+
+/** Error codes */
+typedef enum
+{
+ BCM_ERR_OK = 0, /**< OK */
+ BCM_ERR_IN_PROGRESS = -1, /**< Operation is in progress */
+ BCM_ERR_PARM = -2, /**< Error in parameters */
+ BCM_ERR_NOMEM = -3, /**< No memory */
+ BCM_ERR_NORES = -4, /**< No resources */
+ BCM_ERR_INTERNAL = -5, /**< Internal error */
+ BCM_ERR_NOENT = -6, /**< Entry doesn't exist */
+ BCM_ERR_NODEV = -7, /**< Device doesn't exist */
+ BCM_ERR_ALREADY = -8, /**< Entry already exists */
+ BCM_ERR_RANGE = -9, /**< Out of range */
+ BCM_ERR_PERM = -10, /**< No permission to perform an operation */
+ BCM_ERR_NOT_SUPPORTED = -11, /**< Operation is not supported */
+ BCM_ERR_PARSE = -12, /**< Parsing error */
+ BCM_ERR_INVALID_OP = -13, /**< Invalid operation */
+ BCM_ERR_IO = -14, /**< I/O error */
+ BCM_ERR_STATE = -15, /**< Object is in bad state */
+ BCM_ERR_DELETED = -16, /**< Object is deleted */
+ BCM_ERR_TOO_MANY = -17, /**< Too many objects */
+ BCM_ERR_NO_MORE = -18, /**< No more entries */
+ BCM_ERR_OVERFLOW = -19, /**< Buffer overflow */
+ BCM_ERR_COMM_FAIL = -20, /**< Communication failure */
+ BCM_ERR_NOT_CONNECTED = -21, /**< No connection with the target system */
+ BCM_ERR_SYSCALL_ERR = -22, /**< System call returned error */
+ BCM_ERR_MSG_ERROR = -23, /**< Received message is insane */
+ BCM_ERR_TOO_MANY_REQS = -24, /**< Too many outstanding requests */
+ BCM_ERR_TIMEOUT = -25, /**< Operation timed out */
+ BCM_ERR_TOO_MANY_FRAGS = -26, /**< Too many fragments */
+ BCM_ERR_NULL = -27, /**< Got NULL pointer */
+ BCM_ERR_READ_ONLY = -28, /**< Attempt to set read-only parameter */
+ BCM_ERR_ONU_ERR_RESP = -29, /**< ONU returned an error response */
+ BCM_ERR_MANDATORY_PARM_IS_MISSING = -30, /**< Mandatory parameter is missing */
+ BCM_ERR_KEY_RANGE = -31, /**< Key field was out of range */
+ BCM_ERR_QUEUE_EMPTY = -32, /**< Rx PCIe queue empty */
+ BCM_ERR_QUEUE_FULL = -33, /**< Tx PCIe queue full */
+ BCM_ERR_TOO_LONG = -34, /**< Processing is taking too long, but will finish eventually */
+ BCM_ERR_INSUFFICIENT_LIST_MEM = -35, /**< Not enough memory was provided for variable-length lists */
+
+ BCM_ERR_OUT_OF_SYNC = -36, /**< Sequence number or operation step was out of sync. */
+ BCM_ERR_CHECKSUM = -37, /**< Checksum error */
+ BCM_ERR_IMAGE_TYPE = -38, /**< Unsupported file/image type */
+ BCM_ERR_INCOMPLETE_TERMINATION = -39, /**< Incomplete premature termination */
+} bcmos_errno;
+
+/** Map error code to error string
+ * \param[in] err Error code
+ * \returns Error string
+ */
+const char *bcmos_strerror(bcmos_errno err);
+
+/** @} system_errno */
+
+#endif /* BCMOS_ERRNO_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_hash_table.c b/bcm68620_release/release/host_customized/os_abstraction/bcmos_hash_table.c
new file mode 100644
index 0000000..12e1962
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_hash_table.c
@@ -0,0 +1,467 @@
+/*
+<: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_hash_table.h"
+
+#define ht_overhead sizeof(void *)
+
+/** Create a hash table using a block pool
+ * \param[in] pool_parm pointer to block pool parameters
+ * \param[in] max_data_entries Maximum entries the hash table needs to hold
+ * \param[in] entry_size Size of each entry in bytes
+ * \param[in] key_size Size of each key in bytes
+ * \return pointer to newly created hash table
+ */
+static hash_table *hash_table_create_in_pool(bcmos_blk_pool_parm *pool_parm,
+ uint32_t max_data_entries,
+ uint16_t entry_size,
+ uint8_t key_size)
+{
+ uint32_t lookup_table_entries = max_data_entries + (max_data_entries / 4);
+ hash_table *ht;
+ bcmos_errno err;
+
+ if (pool_parm == NULL)
+ {
+ BUG();
+ return NULL;
+ }
+
+ entry_size += key_size;
+
+ ht = bcmos_alloc(sizeof(hash_table));
+ if (ht == NULL)
+ {
+ BUG();
+ return NULL;
+ }
+
+ ht->obj_len = entry_size;
+ ht->key_len = key_size;
+ ht->data_offset = ht_overhead;
+ ht->ht_lookup_tbl_entries = lookup_table_entries;
+ ht->ht_max_data_entries = max_data_entries;
+ ht->look_up_entries_tbl = bcmos_alloc(lookup_table_entries * sizeof(ht_block));
+
+ if (ht->look_up_entries_tbl == NULL)
+ {
+ bcmos_free(ht);
+ BUG();
+ return NULL;
+ }
+
+ ht->ht_cur_entries = 0;
+ err = bcmos_blk_pool_create(&ht->key_data_pool, pool_parm);
+
+ if (err != BCM_ERR_OK)
+ {
+ bcmos_free(ht->look_up_entries_tbl);
+ bcmos_free(ht);
+ BUG();
+ return NULL;
+ }
+
+ if (ht->ht_max_data_entries > ht->ht_lookup_tbl_entries)
+ {
+ BUG();
+ }
+
+ ht->obj_len -= ht->key_len;
+
+ memset(ht->look_up_entries_tbl, 0, lookup_table_entries * sizeof(ht_block));
+ return ht;
+}
+
+hash_table *hash_table_create(uint32_t max_data_entries,
+ uint16_t entry_size,
+ uint8_t key_size,
+ char *pool_name)
+{
+ bcmos_blk_pool_parm parm = {0};
+
+ parm.name = pool_name;
+ parm.blk_size = entry_size + key_size + ht_overhead;
+ parm.num_blks = max_data_entries;
+
+ return hash_table_create_in_pool(&parm, max_data_entries, entry_size, key_size);
+}
+
+/** Hash a length of bytes into a uint32_t
+ * \param[in] key Bytes to hash
+ * \param[in] len Number of bytes in key
+ * \return The hash as a uint32_t
+ */
+static uint32_t get_hash_for_key(const uint8_t *key, uint8_t len)
+{
+ uint32_t hash = 5381;
+ uint8_t i;
+ const uint8_t *tmp = key;
+ for (i = 0; i < len; tmp++, i++)
+ {
+ hash = ((hash << 5) + hash) + (*tmp);
+ }
+
+ return hash;
+}
+
+/** Gets a hash key used for the keyDataPool in the HashTable
+ * \param[in] ht Associated hashtable we are getting hash for key for
+ * \param[in] key Key we are getting hash for
+ * \return An index into the keyDataPool
+ */
+static uint32_t get_hash_val_for_key(const hash_table *ht, const uint8_t *key)
+{
+ return get_hash_for_key(key, ht->key_len) % ht->ht_lookup_tbl_entries;
+}
+
+/** Returns the location of the key within an HtBlock
+ * \param[in] ht Hash table in question
+ * \param[in] block HtBlock in question
+ * \return pointer to the data within the block
+ */
+static uint8_t *get_key_from_block_in_table(const hash_table *ht, ht_block *block)
+{
+ return(uint8_t *) block + ht->data_offset + ht->obj_len;
+}
+
+/** Gets and populates a HtBlock with all of its data
+ * \param[in] next Next block in this buckets chain
+ * \param[in] ht Hash table in question
+ * \param[in] key This blocks key
+ * \param[in] val This blocks data
+ * \return The block that we allocated and returned
+ */
+static ht_block *fill_ht_block(ht_block *next,
+ hash_table *ht,
+ const uint8_t *key,
+ const void *val)
+{
+ ht_block *dest_block = bcmos_blk_pool_alloc(&ht->key_data_pool);
+
+ if (dest_block != NULL)
+ {
+ /* storage is nextobj ptr, hash obj,
+ key which keeps all uint32_t aligned. */
+ dest_block->next_chain = next;
+
+ if (val != NULL)
+ {
+ memcpy((uint8_t *) dest_block + ht->data_offset, val, ht->obj_len);
+ }
+ else
+ {
+ memset((uint8_t *) dest_block + ht->data_offset,0,ht->obj_len);
+ }
+
+ /* Need to put key in after obj */
+ memcpy(
+ (uint8_t *) dest_block + ht->data_offset + ht->obj_len,
+ key,
+ ht->key_len);
+ }
+
+ return dest_block;
+}
+
+/** Determine whether two keys in a particular hash table match
+ * \param[in] ht Hashtable
+ * \param[in] key_a first key to compare
+ * \param[in] key_b second key to compare
+ * \return whether they are the same
+ */
+static bcmos_bool is_key_match(const hash_table *ht, const uint8_t *key_a, const uint8_t *key_b)
+{
+ return memcmp(key_a, key_b, ht->key_len) == 0;
+}
+
+/** Searches a chained bucket looking for an instance of the key. If found returns the block if found the key in.
+ * Prev guy is set to the block in the chain before the block we returned (except in the case * where there is no
+ * block before the one we returned.
+ * \param[in] ht HashTable in question
+ * \param[in] key_to_find Key we wonder if exists
+ * \param[in] chain_start Where to start looking in the chain
+ * \param[in] prev_block The previous guy before the block we returned (if exists)
+ * \return The block that matches doesExists (if exists)
+ */
+static ht_block *get_key_loc_in_chain(
+ const hash_table *ht,
+ const uint8_t *key_to_find,
+ ht_block *chain_start,
+ ht_block **prev_block)
+{
+ *prev_block = NULL;
+ while (chain_start != NULL)
+ {
+ if (is_key_match(ht, key_to_find, get_key_from_block_in_table(ht, chain_start)))
+ {
+ return chain_start;
+ }
+ *prev_block = chain_start;
+ chain_start = chain_start->next_chain;
+ }
+ return NULL;
+}
+
+bcmos_bool hash_table_remove(hash_table *ht, const uint8_t *key)
+{
+ uint32_t hash_val = get_hash_val_for_key(ht, key);
+ ht_block *prev_entry;
+ ht_block *entry = get_key_loc_in_chain(
+ ht,
+ key,
+ ht->look_up_entries_tbl[hash_val].next_chain,
+ &prev_entry);
+
+ if (entry == NULL)
+ {
+ /* No one to delete */
+ return BCMOS_FALSE;
+ }
+ else
+ {
+ ht->ht_cur_entries--;
+ if (prev_entry == NULL)
+ {
+ /* last entry */
+ ht->look_up_entries_tbl[hash_val].next_chain = entry->next_chain;
+ }
+ else
+ {
+ prev_entry->next_chain = entry->next_chain;
+ }
+ bcmos_blk_pool_free(entry);
+ return BCMOS_TRUE;
+ }
+}
+
+/** Returns a pointer to the data within the HT
+ * \param[in] ht Hashtable in question
+ * \param[in] block_ptr HtBlock that we wonder where its data is
+ */
+static void *get_ht_data_ptr(const hash_table *ht, ht_block *block_ptr)
+{
+ return(uint8_t*)block_ptr + ht->data_offset;
+}
+
+
+/** Get an entry in the hash table
+ * \param[in] ht pointer to hash table
+ * \param[in] key pointer to key data
+ * \param[in] hash_val hash value of key
+ * \return pointer to hash table entry
+ */
+static inline void *ht_get_internal(const hash_table *ht,
+ const uint8_t *key,
+ uint32_t hash_val)
+{
+ ht_block *tmp;
+ ht_block *ret;
+ ret = get_key_loc_in_chain(
+ ht,
+ key,
+ ht->look_up_entries_tbl[hash_val].next_chain,
+ &tmp);
+ if (ret != NULL)
+ {
+ return get_ht_data_ptr(ht,ret);
+ }
+ else
+ {
+ return ret;
+ }
+}
+
+void *hash_table_get(const hash_table *ht, const uint8_t *key)
+{
+ uint32_t hashVal = get_hash_val_for_key(ht, key);
+ return ht_get_internal(ht,key,hashVal);
+}
+
+void *hash_table_put(hash_table *ht, const uint8_t *key, const void *val)
+{
+ void *ret_block;
+ uint32_t hash_val;
+ if (ht->ht_cur_entries >= ht->ht_max_data_entries)
+ {
+ return NULL;
+ }
+ hash_val = get_hash_val_for_key(ht, key);
+
+ ret_block = ht_get_internal((const hash_table *) ht, key, hash_val);
+ if (ret_block != NULL)
+ {
+ /* replace existing value with new value */
+ if (val != NULL)
+ {
+ memcpy(ret_block, val, ht->obj_len);
+ }
+ else
+ {
+ memset(ret_block, 0, ht->obj_len);
+ }
+ return ret_block;
+ }
+ else
+ {
+ ht_block *new_block=fill_ht_block(
+ ht->look_up_entries_tbl[hash_val].next_chain, ht, key, val);
+ if (new_block != NULL)
+ {
+ ht->look_up_entries_tbl[hash_val].next_chain = new_block;
+ ht->ht_cur_entries++;
+ return get_ht_data_ptr(ht,new_block);
+ }
+ else
+ {
+ return NULL;
+ }
+ }
+
+}
+
+ht_iterator ht_iterator_get(const hash_table *ht)
+{
+ ht_iterator to_ret;
+ to_ret.ht = ht;
+ to_ret.cur_idx = 0;
+ to_ret.removed_at = BCMOS_FALSE;
+ to_ret.still_valid = BCMOS_TRUE;
+ to_ret.cur_block = NULL;
+ return to_ret;
+}
+
+ht_iterator ht_iterator_get_by_key(const hash_table *ht, const uint8_t *key)
+{
+ ht_block *tmp;
+ uint32_t hash_val = get_hash_val_for_key(ht, key);
+ ht_iterator to_ret = {};
+ to_ret.ht = ht;
+ to_ret.removed_at = BCMOS_FALSE;
+ to_ret.cur_block = get_key_loc_in_chain(ht, key, ht->look_up_entries_tbl[hash_val].next_chain, &tmp);
+ to_ret.still_valid = (to_ret.cur_block != NULL);
+ to_ret.cur_idx = hash_val;
+
+ return to_ret;
+}
+
+/** Advance linear scan iterator
+ * \param[in] it Iterator to advance
+ */
+static void ht_iterator_scan_adv(ht_iterator *it)
+{
+ if (it->cur_block != NULL)
+ {
+ it->cur_block = it->cur_block->next_chain;
+ if (it->cur_block != NULL)
+ {
+ it->still_valid = BCMOS_TRUE;
+ return;
+ }
+ else
+ {
+ it->cur_idx++;
+ }
+ }
+ /* find non null entry */
+ while (it->cur_idx < it->ht->ht_lookup_tbl_entries)
+ {
+ if (it->ht->look_up_entries_tbl[it->cur_idx].next_chain != NULL)
+ {
+ it->cur_block = it->ht->look_up_entries_tbl[it->cur_idx].next_chain;
+ it->still_valid = BCMOS_TRUE;
+ return;
+ }
+ else
+ {
+ it->cur_idx++;
+ }
+ }
+ it->still_valid = BCMOS_FALSE;
+}
+
+void ht_iterator_deref(const ht_iterator *hti, uint8_t **key, void **obj)
+{
+ if (!hti->still_valid)
+ {
+ BCMOS_TRACE_ERR("%s: Invalid deref\n", __FUNCTION__);
+ }
+ else
+ {
+ *key = get_key_from_block_in_table(hti->ht, hti->cur_block);
+ *obj = get_ht_data_ptr(hti->ht, hti->cur_block); /* to data */
+ }
+}
+
+void ht_iterator_remove_at(hash_table *ht, ht_iterator *it)
+{
+ if (ht != it->ht)
+ {
+ BCMOS_TRACE_ERR("%s: Incorrect writeable hash table pointer\n", __FUNCTION__);
+ }
+ else if (it->removed_at)
+ {
+ BCMOS_TRACE_ERR("%s: No delete twice\n", __FUNCTION__);
+ }
+ else
+ {
+ uint8_t *key;
+ uint8_t *obj;
+ ht_iterator_deref(it, &key, (void **) &obj);
+ it->removed_at = BCMOS_TRUE;
+ it->still_valid = ht_iterator_next(it);
+ if (!hash_table_remove(ht, key))
+ {
+ BCMOS_TRACE_ERR("%s: Remove error\n", __FUNCTION__);
+ }
+ }
+}
+
+bcmos_bool ht_iterator_next(ht_iterator *it)
+{
+ if (it->still_valid)
+ {
+ if (it->removed_at)
+ {
+ it->removed_at = BCMOS_FALSE;
+ }
+ else
+ {
+ ht_iterator_scan_adv(it);
+ }
+ }
+ return it->still_valid; /* No entry found */
+}
+
+void hash_table_clear(hash_table *ht)
+{
+ ht_iterator it = ht_iterator_get(ht);
+ while (ht_iterator_next(&it))
+ {
+ ht_iterator_remove_at(ht, &it);
+ }
+}
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_hash_table.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_hash_table.h
new file mode 100644
index 0000000..15618d6
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_hash_table.h
@@ -0,0 +1,137 @@
+/*
+<: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 BCMOS_HASH_TABLE_H_
+#define BCMOS_HASH_TABLE_H_
+
+#include "bcmos_system.h"
+
+typedef struct ht_block ht_block;
+struct ht_block
+{
+ ht_block *next_chain;
+};
+
+typedef struct
+{
+ uint16_t obj_len;
+ uint8_t key_len;
+ uint32_t data_offset;
+ uint32_t ht_lookup_tbl_entries;
+ uint32_t ht_max_data_entries;
+ bcmos_blk_pool key_data_pool;
+ ht_block *look_up_entries_tbl;
+ uint32_t ht_cur_entries;
+} hash_table;
+
+typedef struct
+{
+ const hash_table *ht;
+ uint32_t cur_idx;
+ ht_block *cur_block;
+ bcmos_bool removed_at;
+ bcmos_bool still_valid;
+} ht_iterator;
+
+/** Create a hash table
+ * \param[in] max_data_entries Maximum entries the hash table needs to hold
+ * \param[in] entry_size Size of each entry in bytes
+ * \param[in] key_size Size of each key in bytes
+ * \param[in] pool_name Friendly name to identify the hash table's memory pool
+ * \return pointer to newly created hash table
+ */
+hash_table *hash_table_create(uint32_t max_data_entries,
+ uint16_t entry_size,
+ uint8_t key_size,
+ char *pool_name);
+
+/** Removes all entries from a HashTable.
+ * \param[in] ht Hash table to remove all entries from
+ */
+void hash_table_clear(hash_table *ht);
+
+/** Gets a pointer to an entry within the hash table (if exists)
+ * \param[in] ht Hashtable in question
+ * \param[in] key Key to look for.
+ * \return Non null if we found a data item associated with KEY.
+ */
+void *hash_table_get(const hash_table *ht, const uint8_t *key);
+
+/** Returns pointers to the key and value that an iterator is pointing at. Warning: key may not be uint32_t aligned.
+ * DO NOT DELETE THE ELEMENT THE ITERATOR POINTS AT AND AND TRY TO USE THE ITERATOR SUBSEQUENTLY. If you need to do
+ * this use ht_iterator_remove_at
+ * \param[in] hti Iterator
+ * \param[in] key Pointer to key to fill
+ * \param[in] obj Pointer to obj to fill.
+ */
+void ht_iterator_deref(const ht_iterator *hti, uint8_t **key, void **obj);
+
+/** Get an interator for traversing a hashtable.
+ * \param[in] ht Hashtable to traverse
+ * \return The iterator.
+ */
+ht_iterator ht_iterator_get(const hash_table *ht);
+
+/** Get an interator for traversing a hashtable based on an entry's key.
+ * \param[in] ht Hashtable to traverse
+ * \param[in] key key of entry to return
+ * \return The iterator.
+ */
+ht_iterator ht_iterator_get_by_key(const hash_table *ht, const uint8_t *key);
+
+/** Advances a HashTable iterator to the next location within the HashTable.
+ * \param[in] it Iterator to advance
+ * \return TRUE if there was a next element
+ */
+bcmos_bool ht_iterator_next(ht_iterator *it);
+
+/** Deletes the entry where the iterator points to and advances the iterator returning whether the advance worked or
+ * not.
+ * \param[in] ht Writable reference to the hash table (the iterator only has read permission)
+ * \param[in] it Itreator pointing at entry to delete.
+ */
+void ht_iterator_remove_at(hash_table *ht, ht_iterator *it);
+
+/** Attempts to associate key with val in the hash table. If key already exists overwrites what was at key with val.
+ * Otherwise allocates an entry within the hashtable for key and copies val into it.
+ * \param[in] ht Hashtable to add or modify
+ * \param[in] key Key to try and associate with val.
+ * \param[in] val Val to associate
+ * \return NULL if fail, else pointer to just added block.
+ */
+void *hash_table_put(hash_table *ht, const uint8_t *key, const void *val);
+
+/** Removes an entry (if exists) from the hash table.
+ * \param[in] ht HashTable to remove from.
+ * \param[in] key Key to remove
+ * \return BCMOS_TRUE if anything was removed, otherwise BCMOS_FALSE.
+ */
+bcmos_bool hash_table_remove(hash_table *ht, const uint8_t *key);
+
+#endif /* Hash.h */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_pack.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_pack.h
new file mode 100644
index 0000000..2161045
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_pack.h
@@ -0,0 +1,67 @@
+/*
+<: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 BCMOS_PACK_H_
+#define BCMOS_PACK_H_
+
+
+/*
+ * Packing macros
+ *
+ * Usage:
+ * struct __PACKED_ATTR_START__ my_packed_struct
+ * {
+ * ...
+ * } __PACKED_ATTR_END__ ;
+ *
+ */
+
+#ifdef __GNUC__
+
+#define __PACKED_ATTR_START__
+#define __PACKED_ATTR_END__ __attribute__ ((packed))
+
+#else
+
+#error define __PACKED_ATTR_START__, __PACKED_ATTR_END__ for this compiler
+
+#endif
+
+/*
+ * Macros for bit-field manipulation
+ * For each field F requires 2 constants
+ * - F_S - field shift
+ * - F_W - field width
+ */
+#define BCM_FIELD_GET(_w, _f) (((_w)>>_f ## _S) & ((1 << _f ## _W) - 1))
+#define BCM_FIELD(_f, _v) ((_v & ((1 << _f ## _W) - 1)) << _f ## _S)
+#define BCM_FIELD_SET(_w, _f, _v) (_w) |= BCM_FIELD(_f, _v)
+
+
+#endif /* BCMOS_PACK_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_platform.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_platform.h
new file mode 100644
index 0000000..7b40fb1
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_platform.h
@@ -0,0 +1,236 @@
+/*
+<: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 BCMOS_PLATFORM_H_
+#define BCMOS_PLATFORM_H_
+
+#ifndef BCMOS_SYSTEM_H_
+#error Please do not include bcmos_platform.h directly. Include bcmos_system.h
+#endif
+
+/** BCM68620 CPU core
+ * \ingroup system_task */
+typedef enum
+{
+ BCMOS_CPU_CORE_ANY, /**< Any core */
+
+ BCMOS_CPU_CORE__NUM_OF = 1, /**< Number of cores */
+} bcmos_core;
+
+#define MAX_NUMBER_OF_PONS_ON_ALL_DEVICES (BCMTR_MAX_OLTS * BCMTR_MAX_INSTANCES)
+
+/** BCM68620 module
+ * \ingroup system_module
+ */
+typedef enum
+{
+ BCMOS_MODULE_ID_NONE, /**< no module */
+
+#ifdef BCMOS_SYS_UNITTEST
+ BCMOS_MODULE_ID_TEST1,
+ BCMOS_MODULE_ID_TEST2,
+#endif
+ /* Each Device (BCM6862X) must have its own dedicated Device Control Module at the host */
+ BCMOS_MODULE_ID_DEV_CTRL_DEV0,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV1,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV2,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV3,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV4,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV5,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV6,
+ BCMOS_MODULE_ID_DEV_CTRL_DEV7,
+
+ /* CLI over PCIe client */
+ BCMOS_MODULE_ID_CLI_OVER_PCIE,
+
+ /* Protection switching user application */
+ BCMOS_MODULE_ID_USER_APPL_PS,
+
+ /* Remote CLI */
+ BCMOS_MODULE_ID_REMOTE_CLI_DEV0,
+
+ /* Remote logger application (To support multiple devices need to add number of devices to previous value) */
+ BCMOS_MODULE_ID_USER_APPL_REMOTE_LOGGER_DEV0 = BCMOS_MODULE_ID_REMOTE_CLI_DEV0 + BCMTR_MAX_OLTS,
+
+ /* OMCI SW download user application (To support multiple devices need to add number of devices to previous value) */
+ BCMOS_MODULE_ID_USER_APPL_OMCI_SWDL_DEV0 = BCMOS_MODULE_ID_USER_APPL_REMOTE_LOGGER_DEV0 + BCMTR_MAX_OLTS,
+
+ /* GPON mac learning / aging user application (To support multiple devices need to add number of devices to previous value)*/
+ BCMOS_MODULE_ID_USER_APPL_GPON_MAC_LEARNING_DEV0 = BCMOS_MODULE_ID_USER_APPL_OMCI_SWDL_DEV0 + BCMTR_MAX_OLTS,
+
+ /* GPON stress user application (To support multiple devices need to add number of devices to previous value)*/
+ BCMOS_MODULE_ID_USER_APPL_GPON_STRESS_DEV0 = BCMOS_MODULE_ID_USER_APPL_GPON_MAC_LEARNING_DEV0 + BCMTR_MAX_OLTS,
+
+ /* GPON DS OMCI packets user application (To support multiple devices need to add number of devices to previous value)*/
+ BCMOS_MODULE_ID_USER_APPL_GPON_DS_OMCI0_DEV0 = BCMOS_MODULE_ID_USER_APPL_GPON_STRESS_DEV0 + BCMTR_MAX_OLTS,
+
+ /* GPON SN acquisition (To support multiple devices need to add number of devices multiply with max PON number to previous value)*/
+ BCMOS_MODULE_ID_USER_APPL_GPON_SN_ACQUISITION0_DEV0 = BCMOS_MODULE_ID_USER_APPL_GPON_DS_OMCI0_DEV0 + MAX_NUMBER_OF_PONS_ON_ALL_DEVICES,
+
+ /* GPON statistics (To support multiple devices need to add number of devices multiply with max PON number to previous value) */
+ BCMOS_MODULE_ID_USER_APPL_GPON_STATISTICS0_DEV0 = BCMOS_MODULE_ID_USER_APPL_GPON_SN_ACQUISITION0_DEV0 + MAX_NUMBER_OF_PONS_ON_ALL_DEVICES,
+
+ /* GPON RSSI user application (To support multiple devices need to add number of devices multiply with max PON number to previous value) */
+ BCMOS_MODULE_ID_USER_APPL_GPON_RSSI_DEV0 = BCMOS_MODULE_ID_USER_APPL_GPON_STATISTICS0_DEV0 + MAX_NUMBER_OF_PONS_ON_ALL_DEVICES,
+
+ /* EPON OAM negotiation application (To support multiple devices need to add number of devices to previous value)*/
+ BCMOS_MODULE_ID_USER_APPL_EON = BCMOS_MODULE_ID_USER_APPL_GPON_RSSI_DEV0 + BCMTR_MAX_OLTS,
+
+ /* EPON optical monitoring application */
+ BCMOS_MODULE_ID_USER_APPL_OMON = BCMOS_MODULE_ID_USER_APPL_EON + BCMTR_MAX_OLTS,
+
+ /* EPON Host driven encryption application */
+ BCMOS_MODULE_ID_USER_APPL_EPON_HDE,
+
+ BCMOS_MODULE_ID_USER_APPL_EPON_OAM,
+
+ BCMOS_MODULE_ID_USER_APPL_DPOE_SEC,
+
+ BCMOS_MODULE_ID_USER_APPL_IMAGE_TRANSFER0 = BCMOS_MODULE_ID_USER_APPL_DPOE_SEC + BCMTR_MAX_OLTS,
+ BCMOS_MODULE_ID_USER_APPL_IMAGE_TRANSFER1,
+
+ BCMOS_MODULE_ID_USER_APPL_ONU_TUNING_DEV0,
+ BCMOS_MODULE_ID_USER_APPL_ONU_TUNING_DEV1,
+
+ BCMOS_MODULE_ID__NUM_OF, /**< Number of modules */
+ BCMOS_MODULE_ID_INVALID = BCMOS_MODULE_ID_NONE
+} bcmos_module_id;
+
+/** BCM68620 event group. Each group supports up to 32 events.
+ * \ingroup system_event
+ */
+typedef enum
+{
+#ifdef BCMOS_SYS_UNITTEST
+ BCMOS_EVENT_ID_TEST1,
+ BCMOS_EVENT_ID_TEST2,
+#else
+ BCMOS_EVENT_ID_DUMMY, /* Currently OS s/w doesn't use events.
+ Remove this constant when adding real events */
+#endif
+
+ BCMOS_EVENT_ID__NUM_OF, /**< Number of event groups */
+} bcmos_event_id;
+
+/** Message hash size
+ * \ingroup system_msg
+ */
+#define BCMOS_MSG_HASH_SIZE 512
+
+/** Maple OS message
+ * \ingroup system_msg
+ */
+typedef enum
+{
+ BCMOS_MSG_ID__BEGIN,
+
+ /* Internal messages */
+ BCMOS_MSG_ID_INTERNAL_TIMER = BCMOS_MSG_ID__BEGIN, /**< Internal "timer message" type */
+ BCMOS_MSG_ID_INTERNAL_EVENT, /**< Internal "event message" type */
+ BCMOS_MSG_ID_INTERNAL_IPC,
+
+ BCMOS_MSG_ID_INITIATE_RX_POWER,
+ BCMOS_MSG_ID_INITIATE_TRX_STATUS,
+ BCMOS_MSG_ID_INITIATE_ROGUE_SCAN,
+ BCMOS_MSG_ID_INITIATE_RSSI_READ,
+
+ BCMOS_MSG_ID_GPON_STRESS_START,
+ BCMOS_MSG_ID_GPON_STRESS_TIMEOUT,
+ BCMOS_MSG_ID_GPON_STRESS_ONU_DISCOVERED,
+ BCMOS_MSG_ID_GPON_STRESS_PON_DEACTIVATION_COMPLETED,
+ BCMOS_MSG_ID_GPON_STRESS_PON_ACTIVATION_COMPLETED,
+ BCMOS_MSG_ID_GPON_STRESS_ALL_ONUS_DEACTIVATION_COMPLETED,
+ BCMOS_MSG_ID_GPON_STRESS_ALL_ONUS_ACTIVATION_COMPLETED,
+ BCMOS_MSG_ID_GPON_STRESS_ONU_DEACTIVATION_COMPLETED,
+ BCMOS_MSG_ID_GPON_STRESS_ONU_ACTIVATION_COMPLETED,
+
+ BCMOS_MSG_ID_GPON_DS_OMCI_START,
+ BCMOS_MSG_ID_GPON_DS_OMCI_TIMEOUT,
+ BCMOS_MSG_ID_GPON_DS_OMCI_STOP,
+ BCMOS_MSG_ID_GPON_DS_OMCI_DEVICE_CONNECTED,
+ BCMOS_MSG_ID_GPON_DS_OMCI_DEVICE_DISCONNECTED,
+
+ BCMOS_MSG_ID_GPON_RSSI_START,
+
+ BCMOS_MSG_ID_GPON_STATISTICS_START,
+ BCMOS_MSG_ID_GPON_STATISTICS_TIMEOUT,
+ BCMOS_MSG_ID_GPON_STATISTICS_STOP,
+
+ BCMOS_MSG_ID_EON_START,
+ BCMOS_MSG_ID_EON_STOP,
+ BCMOS_MSG_ID_EON_PROXY_RX,
+
+ BCMOS_MSG_ID_EPON_OAM_PROXY_RX,
+ BCMOS_MSG_ID_EPON_OAM_TIMEOUT,
+
+ BCMOS_MSG_ID_DPOE_SEC_START,
+ BCMOS_MSG_ID_DPOE_SEC_RX_OAM,
+ BCMOS_MSG_ID_DPOE_SEC_RX_EAPOL,
+
+ BCMOS_MSG_ID_ONU_TUNING_START,
+ BCMOS_MSG_ID_ONU_TUNING_STOP,
+
+ BCMOS_MSG_ID__NONE,
+ BCMOS_MSG_ID__END,
+ BCMOS_MSG_ID__FORCE16 = 0x7fff
+} bcmos_msg_id;
+
+#define BCMOS_MSG_ID__NUM_OF (BCMOS_MSG_ID__END - BCMOS_MSG_ID__BEGIN)
+/*
+ * Task priorities
+ */
+
+#define TASK_PRIORITY_TRANSPORT_TX BCMOS_TASK_PRIORITY_3
+#define TASK_PRIORITY_TRANSPORT_RX BCMOS_TASK_PRIORITY_8
+#define TASK_PRIORITY_TRANSPORT_PROXY BCMOS_TASK_PRIORITY_9
+#define TASK_PRIORITY_TRANSPORT_REMOTE_CLI BCMOS_TASK_PRIORITY_9
+#define TASK_PRIORITY_DEVICE_CONTROL BCMOS_TASK_PRIORITY_10
+#define TASK_PRIORITY_USER_APPL_PS BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_EON BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_OMON BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_EPON_HDE BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_DPOE_SEC BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_GPON_MAC_LEARNING BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_GPON_STRESS BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_GPON_SN_ACQUISITION BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_GPON_DS_OMCI BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_GPON_STATISTICS BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_ONU_TUNING BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_USER_APPL_GPON_RSSI BCMOS_TASK_PRIORITY_12
+#define TASK_PRIORITY_CLI BCMOS_TASK_PRIORITY_15
+#define TASK_PRIORITY_USER_APPL_OMCI_SWDL BCMOS_TASK_PRIORITY_17
+#define TASK_PRIORITY_USER_APPL_IMAGE_TRANSFER BCMOS_TASK_PRIORITY_17
+#define TASK_PRIORITY_DEV_LOG_KERNEL BCMOS_TASK_PRIORITY_20
+#define TASK_PRIORITY_DEV_LOG BCMOS_TASK_PRIORITY_30
+#define TASK_PRIORITY_USER_APPL_REMOTE_LOGGER BCMOS_TASK_PRIORITY_30
+
+
+
+
+#endif /* BCMOS_PLATFORM_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_queue.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_queue.h
new file mode 100644
index 0000000..2172e4d
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_queue.h
@@ -0,0 +1,650 @@
+/*-
+ * Copyright (c) 1991, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 4. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * @(#)queue.h 8.5 (Berkeley) 8/20/94
+ * $FreeBSD$
+ */
+
+#ifndef _SYS_QUEUE_H_
+#define _SYS_QUEUE_H_
+
+/* #include <sys/cdefs.h> */
+
+/*
+ * This file defines four types of data structures: singly-linked lists,
+ * singly-linked tail queues, lists and tail queues.
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction. Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A singly-linked tail queue is headed by a pair of pointers, one to the
+ * head of the list and the other to the tail of the list. The elements are
+ * singly linked for minimum space and pointer manipulation overhead at the
+ * expense of O(n) removal for arbitrary elements. New elements can be added
+ * to the list after an existing element, at the head of the list, or at the
+ * end of the list. Elements being removed from the head of the tail queue
+ * should use the explicit macro for this purpose for optimum efficiency.
+ * A singly-linked tail queue may only be traversed in the forward direction.
+ * Singly-linked tail queues are ideal for applications with large datasets
+ * and few or no removals or for implementing a FIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ *
+ *
+ * SLIST LIST STAILQ TAILQ
+ * _HEAD + + + +
+ * _HEAD_INITIALIZER + + + +
+ * _ENTRY + + + +
+ * _INIT + + + +
+ * _EMPTY + + + +
+ * _FIRST + + + +
+ * _NEXT + + + +
+ * _PREV - - - +
+ * _LAST - - + +
+ * _FOREACH + + + +
+ * _FOREACH_SAFE + + + +
+ * _FOREACH_REVERSE - - - +
+ * _FOREACH_REVERSE_SAFE - - - +
+ * _INSERT_HEAD + + + +
+ * _INSERT_BEFORE - + - +
+ * _INSERT_AFTER + + + +
+ * _INSERT_TAIL - - + +
+ * _CONCAT - - + +
+ * _REMOVE_AFTER + - + -
+ * _REMOVE_HEAD + - + -
+ * _REMOVE + + + +
+ *
+ */
+#ifdef QUEUE_MACRO_DEBUG
+/* Store the last 2 places the queue element or head was altered */
+struct qm_trace {
+ char * lastfile;
+ int lastline;
+ char * prevfile;
+ int prevline;
+};
+
+#define TRACEBUF struct qm_trace trace;
+#define TRASHIT(x) do {(x) = (void *)-1;} while (0)
+
+#define QMD_TRACE_HEAD(head) do { \
+ (head)->trace.prevline = (head)->trace.lastline; \
+ (head)->trace.prevfile = (head)->trace.lastfile; \
+ (head)->trace.lastline = __LINE__; \
+ (head)->trace.lastfile = __FILE__; \
+} while (0)
+
+#define QMD_TRACE_ELEM(elem) do { \
+ (elem)->trace.prevline = (elem)->trace.lastline; \
+ (elem)->trace.prevfile = (elem)->trace.lastfile; \
+ (elem)->trace.lastline = __LINE__; \
+ (elem)->trace.lastfile = __FILE__; \
+} while (0)
+
+#else
+#define QMD_TRACE_ELEM(elem)
+#define QMD_TRACE_HEAD(head)
+#define TRACEBUF
+#define TRASHIT(x)
+#endif /* QUEUE_MACRO_DEBUG */
+
+/* Lint support requires types to be defined using typedefs.
+ No adding "struct" implicitly
+*/
+#ifdef USE_LINT
+#define _Q_TYPE_CAST(type) (type *)
+#define _Q_TYPE_FIELD(type, field) type field
+#else
+#define _Q_TYPE_CAST(type) (struct type *)
+#define _Q_TYPE_FIELD(type, field) struct type field
+#endif
+
+/*
+ * Singly-linked List declarations.
+ */
+#define SLIST_HEAD(name, type) \
+struct name { \
+ _Q_TYPE_FIELD(type, *slh_first); /* first element */ \
+}
+
+#define SLIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define SLIST_ENTRY(type) \
+struct { \
+ _Q_TYPE_FIELD(type, *sle_next); /* next element */ \
+}
+
+/*
+ * Singly-linked List functions.
+ */
+#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
+
+#define SLIST_FIRST(head) ((head)->slh_first)
+
+#define SLIST_FOREACH(var, head, field) \
+ for ((var) = SLIST_FIRST((head)); \
+ (var); \
+ (var) = SLIST_NEXT((var), field))
+
+#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = SLIST_FIRST((head)); \
+ (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
+ (var) = (tvar))
+
+#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
+ for ((varp) = &SLIST_FIRST((head)); \
+ ((var) = *(varp)) != NULL; \
+ (varp) = &SLIST_NEXT((var), field))
+
+#define SLIST_INIT(head) do { \
+ SLIST_FIRST((head)) = NULL; \
+} while (0)
+
+#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
+ SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
+ SLIST_NEXT((slistelm), field) = (elm); \
+} while (0)
+
+#define SLIST_INSERT_HEAD(head, elm, field) do { \
+ SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
+ SLIST_FIRST((head)) = (elm); \
+} while (0)
+
+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
+
+#define SLIST_REMOVE(head, elm, type, field) do { \
+ if (SLIST_FIRST((head)) == (elm)) { \
+ SLIST_REMOVE_HEAD((head), field); \
+ } \
+ else { \
+ _Q_TYPE_FIELD(type, *curelm) = SLIST_FIRST((head)); \
+ while (SLIST_NEXT(curelm, field) != (elm)) \
+ curelm = SLIST_NEXT(curelm, field); \
+ SLIST_REMOVE_AFTER(curelm, field); \
+ } \
+ TRASHIT((elm)->field.sle_next); \
+} while (0)
+
+#define SLIST_REMOVE_AFTER(elm, field) do { \
+ SLIST_NEXT(elm, field) = \
+ SLIST_NEXT(SLIST_NEXT(elm, field), field); \
+} while (0)
+
+#define SLIST_REMOVE_HEAD(head, field) do { \
+ SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
+} while (0)
+
+/*
+ * Singly-linked Tail queue declarations.
+ */
+#define STAILQ_HEAD(name, type) \
+struct name { \
+ _Q_TYPE_FIELD(type, *stqh_first);/* first element */ \
+ _Q_TYPE_FIELD(type, **stqh_last);/* addr of last next element */ \
+}
+
+#define STAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).stqh_first }
+
+#define STAILQ_ENTRY(type) \
+struct { \
+ _Q_TYPE_FIELD(type, *stqe_next); /* next element */ \
+}
+
+/*
+ * Singly-linked Tail queue functions.
+ */
+#define STAILQ_CONCAT(head1, head2) do { \
+ if (!STAILQ_EMPTY((head2))) { \
+ *(head1)->stqh_last = (head2)->stqh_first; \
+ (head1)->stqh_last = (head2)->stqh_last; \
+ STAILQ_INIT((head2)); \
+ } \
+} while (0)
+
+#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
+
+#define STAILQ_FIRST(head) ((head)->stqh_first)
+
+#define STAILQ_FOREACH(var, head, field) \
+ for((var) = STAILQ_FIRST((head)); \
+ (var); \
+ (var) = STAILQ_NEXT((var), field))
+
+
+#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = STAILQ_FIRST((head)); \
+ (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
+ (var) = (tvar))
+
+#define STAILQ_INIT(head) do { \
+ STAILQ_FIRST((head)) = NULL; \
+ (head)->stqh_last = &STAILQ_FIRST((head)); \
+} while (0)
+
+#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
+ if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
+ STAILQ_NEXT((tqelm), field) = (elm); \
+} while (0)
+
+#define STAILQ_INSERT_HEAD(head, elm, field) do { \
+ if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
+ STAILQ_FIRST((head)) = (elm); \
+} while (0)
+
+#define STAILQ_INSERT_TAIL(head, elm, field) do { \
+ STAILQ_NEXT((elm), field) = NULL; \
+ *(head)->stqh_last = (elm); \
+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
+} while (0)
+
+#define STAILQ_LAST(head, type, field) \
+ (STAILQ_EMPTY((head)) ? \
+ _Q_TYPE_CAST(type)NULL : \
+ ((type *)(void *) \
+ ((char *)((head)->stqh_last) - offsetof(type, field))))
+
+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
+
+#define STAILQ_REMOVE(head, elm, type, field) do { \
+ if (STAILQ_FIRST((head)) == (elm)) { \
+ STAILQ_REMOVE_HEAD((head), field); \
+ } \
+ else { \
+ _Q_TYPE_FIELD(type, *curelm) = STAILQ_FIRST((head)); \
+ while (STAILQ_NEXT(curelm, field) != (elm)) \
+ curelm = STAILQ_NEXT(curelm, field); \
+ STAILQ_REMOVE_AFTER(head, curelm, field); \
+ } \
+ TRASHIT((elm)->field.stqe_next); \
+} while (0)
+
+#define STAILQ_REMOVE_SAFE(head, elm, type, field) ({ \
+ _Q_TYPE_FIELD(type, *curelm) = STAILQ_FIRST((head)); \
+ if (curelm == (elm)) { \
+ STAILQ_REMOVE_HEAD((head), field); \
+ } \
+ else { \
+ while (curelm && STAILQ_NEXT(curelm, field) != (elm)) \
+ curelm = STAILQ_NEXT(curelm, field); \
+ if (curelm) \
+ STAILQ_REMOVE_AFTER(head, curelm, field); \
+ }; \
+ TRASHIT((elm)->field.stqe_next); \
+ curelm; \
+})
+
+#define STAILQ_REMOVE_HEAD(head, field) do { \
+ if ((STAILQ_FIRST((head)) = \
+ STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
+ (head)->stqh_last = &STAILQ_FIRST((head)); \
+} while (0)
+
+#define STAILQ_REMOVE_AFTER(head, elm, field) do { \
+ if ((STAILQ_NEXT(elm, field) = \
+ STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \
+ (head)->stqh_last = &STAILQ_NEXT((elm), field); \
+} while (0)
+
+#define STAILQ_SWAP(head1, head2, type) do { \
+ _Q_TYPE_FIELD(type, *swap_first) = STAILQ_FIRST(head1); \
+ _Q_TYPE_FIELD(type, **swap_last) = (head1)->stqh_last; \
+ STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
+ (head1)->stqh_last = (head2)->stqh_last; \
+ STAILQ_FIRST(head2) = swap_first; \
+ (head2)->stqh_last = swap_last; \
+ if (STAILQ_EMPTY(head1)) \
+ (head1)->stqh_last = &STAILQ_FIRST(head1); \
+ if (STAILQ_EMPTY(head2)) \
+ (head2)->stqh_last = &STAILQ_FIRST(head2); \
+} while (0)
+
+
+/*
+ * List declarations.
+ */
+#define DLIST_HEAD(name, type) \
+struct name { \
+ _Q_TYPE_FIELD(type, *lh_first); /* first element */ \
+}
+
+#define DLIST_HEAD_INITIALIZER(head) \
+ { NULL }
+
+#define DLIST_ENTRY(type) \
+struct { \
+ _Q_TYPE_FIELD(type, *le_next); /* next element */ \
+ _Q_TYPE_FIELD(type, **le_prev); /* address of previous next element */ \
+}
+
+/*
+ * List functions.
+ */
+
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define QMD_DLIST_CHECK_HEAD(head, field) do { \
+ if (DLIST_FIRST((head)) != NULL && \
+ DLIST_FIRST((head))->field.le_prev != \
+ &DLIST_FIRST((head))) \
+ panic("Bad list head %p first->prev != head", (head)); \
+} while (0)
+
+#define QMD_DLIST_CHECK_NEXT(elm, field) do { \
+ if (DLIST_NEXT((elm), field) != NULL && \
+ DLIST_NEXT((elm), field)->field.le_prev != \
+ &((elm)->field.le_next)) \
+ panic("Bad link elm %p next->prev != elm", (elm)); \
+} while (0)
+
+#define QMD_DLIST_CHECK_PREV(elm, field) do { \
+ if (*(elm)->field.le_prev != (elm)) \
+ panic("Bad link elm %p prev->next != elm", (elm)); \
+} while (0)
+#else
+#define QMD_DLIST_CHECK_HEAD(head, field)
+#define QMD_DLIST_CHECK_NEXT(elm, field)
+#define QMD_DLIST_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define DLIST_EMPTY(head) ((head)->lh_first == NULL)
+
+#define DLIST_FIRST(head) ((head)->lh_first)
+
+#define DLIST_FOREACH(var, head, field) \
+ for ((var) = DLIST_FIRST((head)); \
+ (var); \
+ (var) = DLIST_NEXT((var), field))
+
+#define DLIST_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = DLIST_FIRST((head)); \
+ (var) && ((tvar) = DLIST_NEXT((var), field), 1); \
+ (var) = (tvar))
+
+#define DLIST_INIT(head) do { \
+ DLIST_FIRST((head)) = NULL; \
+} while (0)
+
+#define DLIST_INSERT_AFTER(listelm, elm, field) do { \
+ QMD_DLIST_CHECK_NEXT(listelm, field); \
+ if ((DLIST_NEXT((elm), field) = DLIST_NEXT((listelm), field)) != NULL)\
+ DLIST_NEXT((listelm), field)->field.le_prev = \
+ &DLIST_NEXT((elm), field); \
+ DLIST_NEXT((listelm), field) = (elm); \
+ (elm)->field.le_prev = &DLIST_NEXT((listelm), field); \
+} while (0)
+
+#define DLIST_INSERT_BEFORE(listelm, elm, field) do { \
+ QMD_DLIST_CHECK_PREV(listelm, field); \
+ (elm)->field.le_prev = (listelm)->field.le_prev; \
+ DLIST_NEXT((elm), field) = (listelm); \
+ *(listelm)->field.le_prev = (elm); \
+ (listelm)->field.le_prev = &DLIST_NEXT((elm), field); \
+} while (0)
+
+#define DLIST_INSERT_HEAD(head, elm, field) do { \
+ QMD_DLIST_CHECK_HEAD((head), field); \
+ if ((DLIST_NEXT((elm), field) = DLIST_FIRST((head))) != NULL) \
+ DLIST_FIRST((head))->field.le_prev = &DLIST_NEXT((elm), field);\
+ DLIST_FIRST((head)) = (elm); \
+ (elm)->field.le_prev = &DLIST_FIRST((head)); \
+} while (0)
+
+#define DLIST_NEXT(elm, field) ((elm)->field.le_next)
+
+#define DLIST_REMOVE(elm, field) do { \
+ if ((elm)->field.le_prev) { \
+ QMD_DLIST_CHECK_NEXT(elm, field); \
+ QMD_DLIST_CHECK_PREV(elm, field); \
+ if (DLIST_NEXT((elm), field) != NULL) \
+ DLIST_NEXT((elm), field)->field.le_prev = \
+ (elm)->field.le_prev; \
+ *(elm)->field.le_prev = DLIST_NEXT((elm), field); \
+ TRASHIT((elm)->field.le_next); \
+ TRASHIT((elm)->field.le_prev); \
+ } \
+} while (0)
+
+#define DLIST_SWAP(head1, head2, type, field) do { \
+ _Q_TYPE_FIELD(type, *swap_tmp) = DLIST_FIRST((head1)); \
+ DLIST_FIRST((head1)) = DLIST_FIRST((head2)); \
+ DLIST_FIRST((head2)) = swap_tmp; \
+ if ((swap_tmp = DLIST_FIRST((head1))) != NULL) \
+ swap_tmp->field.le_prev = &DLIST_FIRST((head1)); \
+ if ((swap_tmp = DLIST_FIRST((head2))) != NULL) \
+ swap_tmp->field.le_prev = &DLIST_FIRST((head2)); \
+} while (0)
+
+/*
+ * Tail queue declarations.
+ */
+#define TAILQ_HEAD(name, type) \
+struct name { \
+ _Q_TYPE_FIELD(type, *tqh_first); /* first element */ \
+ _Q_TYPE_FIELD(type, **tqh_last); /* addr of last next element */ \
+ TRACEBUF \
+}
+
+#define TAILQ_HEAD_INITIALIZER(head) \
+ { NULL, &(head).tqh_first }
+
+#define TAILQ_ENTRY(type) \
+struct { \
+ _Q_TYPE_FIELD(type, *tqe_next); /* next element */ \
+ _Q_TYPE_FIELD(type, **tqe_prev); /* address of previous next element */ \
+ TRACEBUF \
+}
+
+/*
+ * Tail queue functions.
+ */
+#if (defined(_KERNEL) && defined(INVARIANTS))
+#define QMD_TAILQ_CHECK_HEAD(head, field) do { \
+ if (!TAILQ_EMPTY(head) && \
+ TAILQ_FIRST((head))->field.tqe_prev != \
+ &TAILQ_FIRST((head))) \
+ panic("Bad tailq head %p first->prev != head", (head)); \
+} while (0)
+
+#define QMD_TAILQ_CHECK_TAIL(head, field) do { \
+ if (*(head)->tqh_last != NULL) \
+ panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \
+} while (0)
+
+#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \
+ if (TAILQ_NEXT((elm), field) != NULL && \
+ TAILQ_NEXT((elm), field)->field.tqe_prev != \
+ &((elm)->field.tqe_next)) \
+ panic("Bad link elm %p next->prev != elm", (elm)); \
+} while (0)
+
+#define QMD_TAILQ_CHECK_PREV(elm, field) do { \
+ if (*(elm)->field.tqe_prev != (elm)) \
+ panic("Bad link elm %p prev->next != elm", (elm)); \
+} while (0)
+#else
+#define QMD_TAILQ_CHECK_HEAD(head, field)
+#define QMD_TAILQ_CHECK_TAIL(head, headname)
+#define QMD_TAILQ_CHECK_NEXT(elm, field)
+#define QMD_TAILQ_CHECK_PREV(elm, field)
+#endif /* (_KERNEL && INVARIANTS) */
+
+#define TAILQ_CONCAT(head1, head2, field) do { \
+ if (!TAILQ_EMPTY(head2)) { \
+ *(head1)->tqh_last = (head2)->tqh_first; \
+ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
+ (head1)->tqh_last = (head2)->tqh_last; \
+ TAILQ_INIT((head2)); \
+ QMD_TRACE_HEAD(head1); \
+ QMD_TRACE_HEAD(head2); \
+ } \
+} while (0)
+
+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
+
+#define TAILQ_FIRST(head) ((head)->tqh_first)
+
+#define TAILQ_FOREACH(var, head, field) \
+ for ((var) = TAILQ_FIRST((head)); \
+ (var); \
+ (var) = TAILQ_NEXT((var), field))
+
+#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = TAILQ_FIRST((head)); \
+ (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
+ (var) = (tvar))
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
+ for ((var) = TAILQ_LAST((head), headname); \
+ (var); \
+ (var) = TAILQ_PREV((var), headname, field))
+
+#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
+ for ((var) = TAILQ_LAST((head), headname); \
+ (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
+ (var) = (tvar))
+
+#define TAILQ_INIT(head) do { \
+ TAILQ_FIRST((head)) = NULL; \
+ (head)->tqh_last = &TAILQ_FIRST((head)); \
+ QMD_TRACE_HEAD(head); \
+} while (0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
+ QMD_TAILQ_CHECK_NEXT(listelm, field); \
+ if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
+ TAILQ_NEXT((elm), field)->field.tqe_prev = \
+ &TAILQ_NEXT((elm), field); \
+ else { \
+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
+ QMD_TRACE_HEAD(head); \
+ } \
+ TAILQ_NEXT((listelm), field) = (elm); \
+ (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \
+ QMD_TRACE_ELEM(&(elm)->field); \
+ QMD_TRACE_ELEM(&listelm->field); \
+} while (0)
+
+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
+ QMD_TAILQ_CHECK_PREV(listelm, field); \
+ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
+ TAILQ_NEXT((elm), field) = (listelm); \
+ *(listelm)->field.tqe_prev = (elm); \
+ (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \
+ QMD_TRACE_ELEM(&(elm)->field); \
+ QMD_TRACE_ELEM(&listelm->field); \
+} while (0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do { \
+ QMD_TAILQ_CHECK_HEAD(head, field); \
+ if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
+ TAILQ_FIRST((head))->field.tqe_prev = \
+ &TAILQ_NEXT((elm), field); \
+ else \
+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
+ TAILQ_FIRST((head)) = (elm); \
+ (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
+ QMD_TRACE_HEAD(head); \
+ QMD_TRACE_ELEM(&(elm)->field); \
+} while (0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do { \
+ QMD_TAILQ_CHECK_TAIL(head, field); \
+ TAILQ_NEXT((elm), field) = NULL; \
+ (elm)->field.tqe_prev = (head)->tqh_last; \
+ *(head)->tqh_last = (elm); \
+ (head)->tqh_last = &TAILQ_NEXT((elm), field); \
+ QMD_TRACE_HEAD(head); \
+ QMD_TRACE_ELEM(&(elm)->field); \
+} while (0)
+
+#define TAILQ_LAST(head, headname) \
+ (*(((struct headname *)((head)->tqh_last))->tqh_last))
+
+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
+
+#define TAILQ_PREV(elm, headname, field) \
+ (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+
+#define TAILQ_REMOVE(head, elm, field) do { \
+ QMD_TAILQ_CHECK_NEXT(elm, field); \
+ QMD_TAILQ_CHECK_PREV(elm, field); \
+ if ((TAILQ_NEXT((elm), field)) != NULL) \
+ TAILQ_NEXT((elm), field)->field.tqe_prev = \
+ (elm)->field.tqe_prev; \
+ else { \
+ (head)->tqh_last = (elm)->field.tqe_prev; \
+ QMD_TRACE_HEAD(head); \
+ } \
+ *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \
+ TRASHIT((elm)->field.tqe_next); \
+ TRASHIT((elm)->field.tqe_prev); \
+ QMD_TRACE_ELEM(&(elm)->field); \
+} while (0)
+
+#define TAILQ_SWAP(head1, head2, type, field) do { \
+ _Q_TYPE_FIELD(type, *swap_first) = (head1)->tqh_first; \
+ _Q_TYPE_FIELD(type, **swap_last) = (head1)->tqh_last; \
+ (head1)->tqh_first = (head2)->tqh_first; \
+ (head1)->tqh_last = (head2)->tqh_last; \
+ (head2)->tqh_first = swap_first; \
+ (head2)->tqh_last = swap_last; \
+ if ((swap_first = (head1)->tqh_first) != NULL) \
+ swap_first->field.tqe_prev = &(head1)->tqh_first; \
+ else \
+ (head1)->tqh_last = &(head1)->tqh_first; \
+ if ((swap_first = (head2)->tqh_first) != NULL) \
+ swap_first->field.tqe_prev = &(head2)->tqh_first; \
+ else \
+ (head2)->tqh_last = &(head2)->tqh_first; \
+} while (0)
+
+#endif /* !_SYS_QUEUE_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_rw_lock.c b/bcm68620_release/release/host_customized/os_abstraction/bcmos_rw_lock.c
new file mode 100644
index 0000000..27eb5e0
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_rw_lock.c
@@ -0,0 +1,124 @@
+/*
+<: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_rw_lock.h"
+
+struct bcmos_rw_lock
+{
+ /* the actual lock, held by the writer, used by the reader to safely obtain a read lock, but not held to allow
+ * multiple readers */
+ bcmos_mutex lock;
+ /* used by the writer to prevent new readers from obtaining read locks while a writer is waiting */
+ bcmos_mutex read_lock;
+ /* used by readers to signal waiting writers that they have finished reading */
+ bcmos_sem write_lock;
+ /* current number of readers */
+ uint32_t readers;
+};
+
+bcmos_errno bcmos_rw_lock_create(bcmos_rw_lock **lock)
+{
+ bcmos_errno err;
+ *lock = (bcmos_rw_lock*)bcmos_calloc(sizeof(bcmos_rw_lock));
+ if (*lock == NULL)
+ {
+ BUG();
+ return BCM_ERR_NOMEM;
+ }
+ if (BCM_ERR_OK != (err = bcmos_mutex_create(&(*lock)->lock, 0, "bcmos_rw_lock_create_lock")))
+ {
+ BUG();
+ return err;
+ }
+ if (BCM_ERR_OK != (err = bcmos_mutex_create(&(*lock)->read_lock, 0, "bcmos_rw_lock_create_rw_lock")))
+ {
+ BUG();
+ return err;
+ }
+ (*lock)->readers = 0;
+ if (BCM_ERR_OK != (err = bcmos_sem_create(&(*lock)->write_lock, 1, 0, "bcmos_rw_lock_create_write_lock")))
+ {
+ BUG();
+ return err;
+ }
+ return err;
+}
+
+/*lint -e{455} suppress "thread mutex has not been locked" */
+void bcmos_rw_write_lock(bcmos_rw_lock* lock)
+{
+ /* prevent any new readers from trying to obtain a read lock */
+ bcmos_mutex_lock(&lock->read_lock);
+ /* lock the actual lock */
+ bcmos_mutex_lock(&lock->lock);
+ while (lock->readers != 0)
+ {
+ /* there are still readers holding read locks, release the lock */
+ bcmos_mutex_unlock(&lock->lock);
+ /* wait for the signal from the last reader before trying again */
+ bcmos_sem_wait(&lock->write_lock, BCMOS_WAIT_FOREVER);
+ /* lock the actual lock and check for readers again */
+ bcmos_mutex_lock(&lock->lock);
+ }
+ /* no more readers, allow new readers to wait on the lock */
+ bcmos_mutex_unlock(&lock->read_lock);
+}
+/*lint +e{454} suppress "thread mutex has not been locked" */
+
+void bcmos_rw_write_release(bcmos_rw_lock* lock)
+{
+ /*lint --e{455} suppress "thread mutex has not been locked" */
+ bcmos_mutex_unlock(&lock->lock);
+}
+
+void bcmos_rw_read_lock(bcmos_rw_lock* lock)
+{
+ /* wait for anyone trying to get a write lock */
+ bcmos_mutex_lock(&lock->read_lock);
+ /* wait for the lock to be released */
+ bcmos_mutex_lock(&lock->lock);
+ lock->readers++;
+ /* reset the signal to the writers */
+ bcmos_sem_wait(&lock->write_lock, BCMOS_NO_WAIT);
+ /* all done, release everything so other readers can get a read lock */
+ bcmos_mutex_unlock(&lock->lock);
+ bcmos_mutex_unlock(&lock->read_lock);
+}
+
+void bcmos_rw_read_release(bcmos_rw_lock* lock)
+{
+ /* get a lock to prevent interruptions */
+ bcmos_mutex_lock(&lock->lock);
+ if (--lock->readers == 0)
+ {
+ /* if we're the last reader, signal that the lock is available for a writer */
+ bcmos_sem_post(&lock->write_lock);
+ }
+ bcmos_mutex_unlock(&lock->lock);
+}
+
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_rw_lock.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_rw_lock.h
new file mode 100644
index 0000000..b12d533
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_rw_lock.h
@@ -0,0 +1,66 @@
+/*
+<: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.
+
+:>
+ */
+
+/** A write-biased readers-writer lock
+ * NOTE: DO NOT attempt to obtain a write lock on a thread that is already holding a read lock or vice versa - this
+ * will result in a deadlock. Multiple read locks from the same thread are safe, multiple write locks are NOT.
+ */
+#ifndef BCMOS_RW_LOCK_H_
+#define BCMOS_RW_LOCK_H_
+#include "bcmos_system.h"
+
+typedef struct bcmos_rw_lock bcmos_rw_lock;
+
+/** Initialize a lock
+ * \param[out] lock the newly created lock
+ * \return error code
+ */
+bcmos_errno bcmos_rw_lock_create(bcmos_rw_lock **lock);
+
+/** Obtain a write lock
+ * \param[in] lock the lock to operate on
+ */
+void bcmos_rw_write_lock(bcmos_rw_lock* lock);
+
+/** Release a write lock
+ * \param[in] lock the lock to operate on
+ */
+void bcmos_rw_write_release(bcmos_rw_lock* lock);
+
+/** Obtain a read lock
+ * \param[in] lock the lock to operate on
+ */
+void bcmos_rw_read_lock(bcmos_rw_lock* lock);
+
+/** Release a read lock
+ * \param[in] lock the lock to operate on
+ */
+void bcmos_rw_read_release(bcmos_rw_lock* lock);
+
+#endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_sysif.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_sysif.h
new file mode 100644
index 0000000..43df6dc
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_sysif.h
@@ -0,0 +1,93 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmos_sysif.h
+ *
+ * This internal header file includes OS-specific services
+ * that are referred in OS-independent OS abstraction implementation
+ *
+ */
+
+#ifndef BCMOS_SYSIF_H_
+#define BCMOS_SYSIF_H_
+
+/*
+ * OS-specific init
+ */
+
+/** Initialize system library
+ * Must be called before any other system function
+ * \returns 0=OK or error code <0
+ */
+bcmos_errno bcmos_sys_init(void);
+
+/** Clean-up system library
+ */
+void bcmos_sys_exit(void);
+
+
+/*
+ * Timer support
+ */
+
+/* OS abstraction must define struct bcmos_sys_timer
+ */
+typedef struct bcmos_sys_timer bcmos_sys_timer;
+
+/* System timer handler. Implemented in common OS abstraction services */
+typedef void (*bcmos_sys_timer_handler)(void *data);
+
+/* Create system timer
+ * It is expected that only one high-resolution system timer is needed.
+ * It is used to "kick" timer pool implemented in OS abstraction
+ * \param[in] timer System timer
+ * \param[in] handler Timer handler
+ * \param[in] data Data to be passed to the handler
+ * \returns 0 if OK or error < 0
+ */
+bcmos_errno bcmos_sys_timer_create(bcmos_sys_timer *timer, bcmos_sys_timer_handler handler, void *data);
+
+/* Destroy system timer
+ * \param[in] timer System timer
+ */
+void bcmos_sys_timer_destroy(bcmos_sys_timer *timer);
+
+/* Start system timer
+ * \param[in] timer System timer
+ * \param[in] interval Interval (us)
+ */
+void bcmos_sys_timer_start(bcmos_sys_timer *timer, uint32_t interval);
+
+/* Stop system timer
+ * \param[in] timer System timer
+ */
+void bcmos_sys_timer_stop(bcmos_sys_timer *timer);
+
+#endif /* BCMOS_SYSIF_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_tree.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_tree.h
new file mode 100755
index 0000000..82d9164
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_tree.h
@@ -0,0 +1,765 @@
+/* $NetBSD: tree.h,v 1.8 2004/03/28 19:38:30 provos Exp $ */
+/* $OpenBSD: tree.h,v 1.7 2002/10/17 21:51:54 art Exp $ */
+/* $FreeBSD$ */
+
+/*-
+ * Copyright 2002 Niels Provos <provos@citi.umich.edu>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef _BCMOS_TREE_H_
+#define _BCMOS_TREE_H_
+
+/*
+ * This file defines data structures for different types of trees:
+ * splay trees and red-black trees.
+ *
+ * A splay tree is a self-organizing data structure. Every operation
+ * on the tree causes a splay to happen. The splay moves the requested
+ * node to the root of the tree and partly rebalances it.
+ *
+ * This has the benefit that request locality causes faster lookups as
+ * the requested nodes move to the top of the tree. On the other hand,
+ * every lookup causes memory writes.
+ *
+ * The Balance Theorem bounds the total access time for m operations
+ * and n inserts on an initially empty tree as O((m + n)lg n). The
+ * amortized cost for a sequence of m accesses to a splay tree is O(lg n);
+ *
+ * A red-black tree is a binary search tree with the node color as an
+ * extra attribute. It fulfills a set of conditions:
+ * - every search path from the root to a leaf consists of the
+ * same number of black nodes,
+ * - each red node (except for the root) has a black parent,
+ * - each leaf node is black.
+ *
+ * Every operation on a red-black tree is bounded as O(lg n).
+ * The maximum height of a red-black tree is 2lg (n+1).
+ */
+
+#define SPLAY_HEAD(name, type) \
+struct name { \
+ type *sph_root; /* root of the tree */ \
+}
+
+#define SPLAY_INITIALIZER(root) \
+ { NULL }
+
+#define SPLAY_INIT(root) do { \
+ (root)->sph_root = NULL; \
+} while (/*CONSTCOND*/ 0)
+
+#define SPLAY_ENTRY(type) \
+struct { \
+ type *spe_left; /* left element */ \
+ type *spe_right; /* right element */ \
+}
+
+#define SPLAY_LEFT(elm, field) (elm)->field.spe_left
+#define SPLAY_RIGHT(elm, field) (elm)->field.spe_right
+#define SPLAY_ROOT(head) (head)->sph_root
+#define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL)
+
+/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */
+#define SPLAY_ROTATE_RIGHT(head, tmp, field) do { \
+ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \
+ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
+ (head)->sph_root = tmp; \
+} while (/*CONSTCOND*/ 0)
+
+#define SPLAY_ROTATE_LEFT(head, tmp, field) do { \
+ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \
+ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
+ (head)->sph_root = tmp; \
+} while (/*CONSTCOND*/ 0)
+
+#define SPLAY_LINKLEFT(head, tmp, field) do { \
+ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
+ tmp = (head)->sph_root; \
+ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \
+} while (/*CONSTCOND*/ 0)
+
+#define SPLAY_LINKRIGHT(head, tmp, field) do { \
+ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
+ tmp = (head)->sph_root; \
+ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \
+} while (/*CONSTCOND*/ 0)
+
+#define SPLAY_ASSEMBLE(head, node, left, right, field) do { \
+ SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field); \
+ SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);\
+ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field); \
+ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field); \
+} while (/*CONSTCOND*/ 0)
+
+/* Generates prototypes and inline functions */
+
+#define SPLAY_PROTOTYPE(name, type, field, cmp) \
+void name##_SPLAY(struct name *, type *); \
+void name##_SPLAY_MINMAX(struct name *, int); \
+type *name##_SPLAY_INSERT(struct name *, type *); \
+type *name##_SPLAY_REMOVE(struct name *, type *); \
+ \
+/* Finds the node with the same key as elm */ \
+static __inline type * \
+name##_SPLAY_FIND(struct name *head, type *elm) \
+{ \
+ if (SPLAY_EMPTY(head)) \
+ return(NULL); \
+ name##_SPLAY(head, elm); \
+ if ((cmp)(elm, (head)->sph_root) == 0) \
+ return (head->sph_root); \
+ return (NULL); \
+} \
+ \
+static __inline type * \
+name##_SPLAY_NEXT(struct name *head, type *elm) \
+{ \
+ name##_SPLAY(head, elm); \
+ if (SPLAY_RIGHT(elm, field) != NULL) { \
+ elm = SPLAY_RIGHT(elm, field); \
+ while (SPLAY_LEFT(elm, field) != NULL) { \
+ elm = SPLAY_LEFT(elm, field); \
+ } \
+ } else \
+ elm = NULL; \
+ return (elm); \
+} \
+ \
+static __inline type * \
+name##_SPLAY_MIN_MAX(struct name *head, int val) \
+{ \
+ name##_SPLAY_MINMAX(head, val); \
+ return (SPLAY_ROOT(head)); \
+}
+
+/* Main splay operation.
+ * Moves node close to the key of elm to top
+ */
+#define SPLAY_GENERATE(name, type, field, cmp) \
+type * \
+name##_SPLAY_INSERT(struct name *head, type *elm) \
+{ \
+ if (SPLAY_EMPTY(head)) { \
+ SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL; \
+ } else { \
+ int __comp; \
+ name##_SPLAY(head, elm); \
+ __comp = (cmp)(elm, (head)->sph_root); \
+ if(__comp < 0) { \
+ SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field);\
+ SPLAY_RIGHT(elm, field) = (head)->sph_root; \
+ SPLAY_LEFT((head)->sph_root, field) = NULL; \
+ } else if (__comp > 0) { \
+ SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field);\
+ SPLAY_LEFT(elm, field) = (head)->sph_root; \
+ SPLAY_RIGHT((head)->sph_root, field) = NULL; \
+ } else \
+ return ((head)->sph_root); \
+ } \
+ (head)->sph_root = (elm); \
+ return (NULL); \
+} \
+ \
+type * \
+name##_SPLAY_REMOVE(struct name *head, type *elm) \
+{ \
+ type *__tmp; \
+ if (SPLAY_EMPTY(head)) \
+ return (NULL); \
+ name##_SPLAY(head, elm); \
+ if ((cmp)(elm, (head)->sph_root) == 0) { \
+ if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \
+ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);\
+ } else { \
+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
+ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);\
+ name##_SPLAY(head, elm); \
+ SPLAY_RIGHT((head)->sph_root, field) = __tmp; \
+ } \
+ return (elm); \
+ } \
+ return (NULL); \
+} \
+ \
+void \
+name##_SPLAY(struct name *head, type *elm) \
+{ \
+ type __node, *__left, *__right, *__tmp; \
+ int __comp; \
+\
+ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
+ __left = __right = &__node; \
+\
+ while ((__comp = (cmp)(elm, (head)->sph_root)) != 0) { \
+ if (__comp < 0) { \
+ __tmp = SPLAY_LEFT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if ((cmp)(elm, __tmp) < 0){ \
+ SPLAY_ROTATE_RIGHT(head, __tmp, field); \
+ if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
+ break; \
+ } \
+ SPLAY_LINKLEFT(head, __right, field); \
+ } else if (__comp > 0) { \
+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if ((cmp)(elm, __tmp) > 0){ \
+ SPLAY_ROTATE_LEFT(head, __tmp, field); \
+ if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
+ break; \
+ } \
+ SPLAY_LINKRIGHT(head, __left, field); \
+ } \
+ } \
+ SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
+} \
+ \
+/* Splay with either the minimum or the maximum element \
+ * Used to find minimum or maximum element in tree. \
+ */ \
+void name##_SPLAY_MINMAX(struct name *head, int __comp) \
+{ \
+ type __node, *__left, *__right, *__tmp; \
+\
+ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
+ __left = __right = &__node; \
+\
+ while (1) { \
+ if (__comp < 0) { \
+ __tmp = SPLAY_LEFT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if (__comp < 0){ \
+ SPLAY_ROTATE_RIGHT(head, __tmp, field); \
+ if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
+ break; \
+ } \
+ SPLAY_LINKLEFT(head, __right, field); \
+ } else if (__comp > 0) { \
+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if (__comp > 0) { \
+ SPLAY_ROTATE_LEFT(head, __tmp, field); \
+ if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
+ break; \
+ } \
+ SPLAY_LINKRIGHT(head, __left, field); \
+ } \
+ } \
+ SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
+}
+
+#define SPLAY_NEGINF -1
+#define SPLAY_INF 1
+
+#define SPLAY_INSERT(name, x, y) name##_SPLAY_INSERT(x, y)
+#define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y)
+#define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y)
+#define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y)
+#define SPLAY_MIN(name, x) (SPLAY_EMPTY(x) ? NULL \
+ : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
+#define SPLAY_MAX(name, x) (SPLAY_EMPTY(x) ? NULL \
+ : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
+
+#define SPLAY_FOREACH(x, name, head) \
+ for ((x) = SPLAY_MIN(name, head); \
+ (x) != NULL; \
+ (x) = SPLAY_NEXT(name, head, x))
+
+/* Macros that define a red-black tree */
+#define RB_HEAD(name, type) \
+struct name { \
+ type *rbh_root; /* root of the tree */ \
+}
+
+#define RB_INITIALIZER(root) \
+ { NULL }
+
+#define RB_INIT(root) do { \
+ (root)->rbh_root = NULL; \
+} while (/*CONSTCOND*/ 0)
+
+#define RB_BLACK 0
+#define RB_RED 1
+#define RB_ENTRY(type) \
+struct { \
+ type *rbe_left; /* left element */ \
+ type *rbe_right; /* right element */ \
+ type *rbe_parent; /* parent element */ \
+ int rbe_color; /* node color */ \
+}
+
+#define RB_LEFT(elm, field) (elm)->field.rbe_left
+#define RB_RIGHT(elm, field) (elm)->field.rbe_right
+#define RB_PARENT(elm, field) (elm)->field.rbe_parent
+#define RB_COLOR(elm, field) (elm)->field.rbe_color
+#define RB_ROOT_NODE(head) (head)->rbh_root
+#define RB_EMPTY(head) (RB_ROOT_NODE(head) == NULL)
+
+#define RB_SET(elm, parent, field) do { \
+ RB_PARENT(elm, field) = parent; \
+ RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL; \
+ RB_COLOR(elm, field) = RB_RED; \
+} while (/*CONSTCOND*/ 0)
+
+#define RB_SET_BLACKRED(black, red, field) do { \
+ RB_COLOR(black, field) = RB_BLACK; \
+ RB_COLOR(red, field) = RB_RED; \
+} while (/*CONSTCOND*/ 0)
+
+#ifndef RB_AUGMENT
+#define RB_AUGMENT(x) do {} while (0)
+#endif
+
+#define RB_ROTATE_LEFT(head, elm, tmp, field) do { \
+ (tmp) = RB_RIGHT(elm, field); \
+ if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field)) != NULL) { \
+ RB_PARENT(RB_LEFT(tmp, field), field) = (elm); \
+ } \
+ RB_AUGMENT(elm); \
+ if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) { \
+ if ((elm) == RB_LEFT(RB_PARENT(elm, field), field)) \
+ RB_LEFT(RB_PARENT(elm, field), field) = (tmp); \
+ else \
+ RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \
+ } else \
+ (head)->rbh_root = (tmp); \
+ RB_LEFT(tmp, field) = (elm); \
+ RB_PARENT(elm, field) = (tmp); \
+ RB_AUGMENT(tmp); \
+ if ((RB_PARENT(tmp, field))) \
+ RB_AUGMENT(RB_PARENT(tmp, field)); \
+} while (/*CONSTCOND*/ 0)
+
+#define RB_ROTATE_RIGHT(head, elm, tmp, field) do { \
+ (tmp) = RB_LEFT(elm, field); \
+ if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field)) != NULL) { \
+ RB_PARENT(RB_RIGHT(tmp, field), field) = (elm); \
+ } \
+ RB_AUGMENT(elm); \
+ if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field)) != NULL) { \
+ if ((elm) == RB_LEFT(RB_PARENT(elm, field), field)) \
+ RB_LEFT(RB_PARENT(elm, field), field) = (tmp); \
+ else \
+ RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \
+ } else \
+ (head)->rbh_root = (tmp); \
+ RB_RIGHT(tmp, field) = (elm); \
+ RB_PARENT(elm, field) = (tmp); \
+ RB_AUGMENT(tmp); \
+ if ((RB_PARENT(tmp, field))) \
+ RB_AUGMENT(RB_PARENT(tmp, field)); \
+} while (/*CONSTCOND*/ 0)
+
+/* Generates prototypes and inline functions */
+#define RB_PROTOTYPE(name, type, field, cmp) \
+ RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
+#define RB_PROTOTYPE_STATIC(name, type, field, cmp) \
+ RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __unused static)
+#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
+attr void name##_RB_INSERT_COLOR(struct name *, type *); \
+attr void name##_RB_REMOVE_COLOR(struct name *, type *, type *); \
+attr type *name##_RB_REMOVE(struct name *, type *); \
+attr type *name##_RB_INSERT(struct name *, type *); \
+attr type *name##_RB_FIND(struct name *, type *); \
+attr type *name##_RB_NFIND(struct name *, type *); \
+attr type *name##_RB_NEXT(type *); \
+attr type *name##_RB_PREV(type *); \
+attr type *name##_RB_MINMAX(struct name *, int); \
+ \
+
+/* Main rb operation.
+ * Moves node close to the key of elm to top
+ */
+#define RB_GENERATE(name, type, field, cmp) \
+ RB_GENERATE_INTERNAL(name, type, field, cmp,)
+#define RB_GENERATE_STATIC(name, type, field, cmp) \
+ RB_GENERATE_INTERNAL(name, type, field, cmp, __unused static)
+#define RB_GENERATE_INLINE(name, type, field, cmp) \
+ RB_GENERATE_INTERNAL(name, type, field, cmp, static inline)
+#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr) \
+attr void \
+name##_RB_INSERT_COLOR(struct name *head, type *elm) \
+{ \
+ type *parent, *gparent, *tmp; \
+ while ((parent = RB_PARENT(elm, field)) != NULL && \
+ RB_COLOR(parent, field) == RB_RED) { \
+ gparent = RB_PARENT(parent, field); \
+ if (parent == RB_LEFT(gparent, field)) { \
+ tmp = RB_RIGHT(gparent, field); \
+ if (tmp && RB_COLOR(tmp, field) == RB_RED) { \
+ RB_COLOR(tmp, field) = RB_BLACK; \
+ RB_SET_BLACKRED(parent, gparent, field);\
+ elm = gparent; \
+ continue; \
+ } \
+ if (RB_RIGHT(parent, field) == elm) { \
+ RB_ROTATE_LEFT(head, parent, tmp, field);\
+ tmp = parent; \
+ parent = elm; \
+ elm = tmp; \
+ } \
+ RB_SET_BLACKRED(parent, gparent, field); \
+ RB_ROTATE_RIGHT(head, gparent, tmp, field); \
+ } else { \
+ tmp = RB_LEFT(gparent, field); \
+ if (tmp && RB_COLOR(tmp, field) == RB_RED) { \
+ RB_COLOR(tmp, field) = RB_BLACK; \
+ RB_SET_BLACKRED(parent, gparent, field);\
+ elm = gparent; \
+ continue; \
+ } \
+ if (RB_LEFT(parent, field) == elm) { \
+ RB_ROTATE_RIGHT(head, parent, tmp, field);\
+ tmp = parent; \
+ parent = elm; \
+ elm = tmp; \
+ } \
+ RB_SET_BLACKRED(parent, gparent, field); \
+ RB_ROTATE_LEFT(head, gparent, tmp, field); \
+ } \
+ } \
+ RB_COLOR(head->rbh_root, field) = RB_BLACK; \
+} \
+ \
+attr void \
+name##_RB_REMOVE_COLOR(struct name *head, type *parent, type *elm) \
+{ \
+ type *tmp; \
+ while ((elm == NULL || RB_COLOR(elm, field) == RB_BLACK) && \
+ elm != RB_ROOT_NODE(head)) { \
+ if (RB_LEFT(parent, field) == elm) { \
+ tmp = RB_RIGHT(parent, field); \
+ if (RB_COLOR(tmp, field) == RB_RED) { \
+ RB_SET_BLACKRED(tmp, parent, field); \
+ RB_ROTATE_LEFT(head, parent, tmp, field);\
+ tmp = RB_RIGHT(parent, field); \
+ } \
+ if ((RB_LEFT(tmp, field) == NULL || \
+ RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&\
+ (RB_RIGHT(tmp, field) == NULL || \
+ RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {\
+ RB_COLOR(tmp, field) = RB_RED; \
+ elm = parent; \
+ parent = RB_PARENT(elm, field); \
+ } else { \
+ if (RB_RIGHT(tmp, field) == NULL || \
+ RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) {\
+ type *oleft; \
+ if ((oleft = RB_LEFT(tmp, field)) \
+ != NULL) \
+ RB_COLOR(oleft, field) = RB_BLACK;\
+ RB_COLOR(tmp, field) = RB_RED; \
+ RB_ROTATE_RIGHT(head, tmp, oleft, field);\
+ tmp = RB_RIGHT(parent, field); \
+ } \
+ RB_COLOR(tmp, field) = RB_COLOR(parent, field);\
+ RB_COLOR(parent, field) = RB_BLACK; \
+ if (RB_RIGHT(tmp, field)) \
+ RB_COLOR(RB_RIGHT(tmp, field), field) = RB_BLACK;\
+ RB_ROTATE_LEFT(head, parent, tmp, field);\
+ elm = RB_ROOT_NODE(head); \
+ break; \
+ } \
+ } else { \
+ tmp = RB_LEFT(parent, field); \
+ if (RB_COLOR(tmp, field) == RB_RED) { \
+ RB_SET_BLACKRED(tmp, parent, field); \
+ RB_ROTATE_RIGHT(head, parent, tmp, field);\
+ tmp = RB_LEFT(parent, field); \
+ } \
+ if ((RB_LEFT(tmp, field) == NULL || \
+ RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&\
+ (RB_RIGHT(tmp, field) == NULL || \
+ RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {\
+ RB_COLOR(tmp, field) = RB_RED; \
+ elm = parent; \
+ parent = RB_PARENT(elm, field); \
+ } else { \
+ if (RB_LEFT(tmp, field) == NULL || \
+ RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) {\
+ type *oright; \
+ if ((oright = RB_RIGHT(tmp, field)) \
+ != NULL) \
+ RB_COLOR(oright, field) = RB_BLACK;\
+ RB_COLOR(tmp, field) = RB_RED; \
+ RB_ROTATE_LEFT(head, tmp, oright, field);\
+ tmp = RB_LEFT(parent, field); \
+ } \
+ RB_COLOR(tmp, field) = RB_COLOR(parent, field);\
+ RB_COLOR(parent, field) = RB_BLACK; \
+ if (RB_LEFT(tmp, field)) \
+ RB_COLOR(RB_LEFT(tmp, field), field) = RB_BLACK;\
+ RB_ROTATE_RIGHT(head, parent, tmp, field);\
+ elm = RB_ROOT_NODE(head); \
+ break; \
+ } \
+ } \
+ } \
+ if (elm) \
+ RB_COLOR(elm, field) = RB_BLACK; \
+} \
+ \
+attr type * \
+name##_RB_REMOVE(struct name *head, type *elm) \
+{ \
+ type *child, *parent, *old = elm; \
+ int color; \
+ if (RB_LEFT(elm, field) == NULL) \
+ child = RB_RIGHT(elm, field); \
+ else if (RB_RIGHT(elm, field) == NULL) \
+ child = RB_LEFT(elm, field); \
+ else { \
+ type *left; \
+ elm = RB_RIGHT(elm, field); \
+ while ((left = RB_LEFT(elm, field)) != NULL) \
+ elm = left; \
+ child = RB_RIGHT(elm, field); \
+ parent = RB_PARENT(elm, field); \
+ color = RB_COLOR(elm, field); \
+ if (child) \
+ RB_PARENT(child, field) = parent; \
+ if (parent) { \
+ if (RB_LEFT(parent, field) == elm) \
+ RB_LEFT(parent, field) = child; \
+ else \
+ RB_RIGHT(parent, field) = child; \
+ RB_AUGMENT(parent); \
+ } else \
+ RB_ROOT_NODE(head) = child; \
+ if (RB_PARENT(elm, field) == old) \
+ parent = elm; \
+ (elm)->field = (old)->field; \
+ if (RB_PARENT(old, field)) { \
+ if (RB_LEFT(RB_PARENT(old, field), field) == old)\
+ RB_LEFT(RB_PARENT(old, field), field) = elm;\
+ else \
+ RB_RIGHT(RB_PARENT(old, field), field) = elm;\
+ RB_AUGMENT(RB_PARENT(old, field)); \
+ } else \
+ RB_ROOT_NODE(head) = elm; \
+ RB_PARENT(RB_LEFT(old, field), field) = elm; \
+ if (RB_RIGHT(old, field)) \
+ RB_PARENT(RB_RIGHT(old, field), field) = elm; \
+ if (parent) { \
+ left = parent; \
+ do { \
+ RB_AUGMENT(left); \
+ } while ((left = RB_PARENT(left, field)) != NULL); \
+ } \
+ goto color; \
+ } \
+ parent = RB_PARENT(elm, field); \
+ color = RB_COLOR(elm, field); \
+ if (child) \
+ RB_PARENT(child, field) = parent; \
+ if (parent) { \
+ if (RB_LEFT(parent, field) == elm) \
+ RB_LEFT(parent, field) = child; \
+ else \
+ RB_RIGHT(parent, field) = child; \
+ RB_AUGMENT(parent); \
+ } else \
+ RB_ROOT_NODE(head) = child; \
+color: \
+ if (color == RB_BLACK) \
+ name##_RB_REMOVE_COLOR(head, parent, child); \
+ return (old); \
+} \
+ \
+/* Inserts a node into the RB tree */ \
+attr type * \
+name##_RB_INSERT(struct name *head, type *elm) \
+{ \
+ type *tmp; \
+ type *parent = NULL; \
+ int comp = 0; \
+ tmp = RB_ROOT_NODE(head); \
+ while (tmp) { \
+ parent = tmp; \
+ comp = (cmp)(elm, parent); \
+ if (comp < 0) \
+ tmp = RB_LEFT(tmp, field); \
+ else if (comp > 0) \
+ tmp = RB_RIGHT(tmp, field); \
+ else \
+ return (tmp); \
+ } \
+ RB_SET(elm, parent, field); \
+ if (parent != NULL) { \
+ if (comp < 0) \
+ RB_LEFT(parent, field) = elm; \
+ else \
+ RB_RIGHT(parent, field) = elm; \
+ RB_AUGMENT(parent); \
+ } else \
+ RB_ROOT_NODE(head) = elm; \
+ name##_RB_INSERT_COLOR(head, elm); \
+ return (NULL); \
+} \
+ \
+/* Finds the node with the same key as elm */ \
+attr type * \
+name##_RB_FIND(struct name *head, type *elm) \
+{ \
+ type *tmp = RB_ROOT_NODE(head); \
+ int comp; \
+ while (tmp) { \
+ comp = cmp(elm, tmp); \
+ if (comp < 0) \
+ tmp = RB_LEFT(tmp, field); \
+ else if (comp > 0) \
+ tmp = RB_RIGHT(tmp, field); \
+ else \
+ return (tmp); \
+ } \
+ return (NULL); \
+} \
+ \
+/* Finds the first node greater than or equal to the search key */ \
+attr type * \
+name##_RB_NFIND(struct name *head, type *elm) \
+{ \
+ type *tmp = RB_ROOT_NODE(head); \
+ type *res = NULL; \
+ int comp; \
+ while (tmp) { \
+ comp = cmp(elm, tmp); \
+ if (comp < 0) { \
+ res = tmp; \
+ tmp = RB_LEFT(tmp, field); \
+ } \
+ else if (comp > 0) \
+ tmp = RB_RIGHT(tmp, field); \
+ else \
+ return (tmp); \
+ } \
+ return (res); \
+} \
+ \
+/* ARGSUSED */ \
+attr type * \
+name##_RB_NEXT(type *elm) \
+{ \
+ if (RB_RIGHT(elm, field)) { \
+ elm = RB_RIGHT(elm, field); \
+ while (RB_LEFT(elm, field)) \
+ elm = RB_LEFT(elm, field); \
+ } else { \
+ if (RB_PARENT(elm, field) && \
+ (elm == RB_LEFT(RB_PARENT(elm, field), field))) \
+ elm = RB_PARENT(elm, field); \
+ else { \
+ while (RB_PARENT(elm, field) && \
+ (elm == RB_RIGHT(RB_PARENT(elm, field), field)))\
+ elm = RB_PARENT(elm, field); \
+ elm = RB_PARENT(elm, field); \
+ } \
+ } \
+ return (elm); \
+} \
+ \
+/* ARGSUSED */ \
+attr type * \
+name##_RB_PREV(type *elm) \
+{ \
+ if (RB_LEFT(elm, field)) { \
+ elm = RB_LEFT(elm, field); \
+ while (RB_RIGHT(elm, field)) \
+ elm = RB_RIGHT(elm, field); \
+ } else { \
+ if (RB_PARENT(elm, field) && \
+ (elm == RB_RIGHT(RB_PARENT(elm, field), field))) \
+ elm = RB_PARENT(elm, field); \
+ else { \
+ while (RB_PARENT(elm, field) && \
+ (elm == RB_LEFT(RB_PARENT(elm, field), field)))\
+ elm = RB_PARENT(elm, field); \
+ elm = RB_PARENT(elm, field); \
+ } \
+ } \
+ return (elm); \
+} \
+ \
+attr type * \
+name##_RB_MINMAX(struct name *head, int val) \
+{ \
+ type *tmp = RB_ROOT_NODE(head); \
+ type *parent = NULL; \
+ while (tmp) { \
+ parent = tmp; \
+ if (val < 0) \
+ tmp = RB_LEFT(tmp, field); \
+ else \
+ tmp = RB_RIGHT(tmp, field); \
+ } \
+ return (parent); \
+}
+
+#define RB_NEGINF -1
+#define RB_INF 1
+
+#define RB_INSERT(name, x, y) name##_RB_INSERT(x, y)
+#define RB_REMOVE(name, x, y) name##_RB_REMOVE(x, y)
+#define RB_FIND(name, x, y) name##_RB_FIND(x, y)
+#define RB_NFIND(name, x, y) name##_RB_NFIND(x, y)
+#define RB_NEXT(name, x, y) name##_RB_NEXT(y)
+#define RB_PREV(name, x, y) name##_RB_PREV(y)
+#define RB_MIN(name, x) name##_RB_MINMAX(x, RB_NEGINF)
+#define RB_MAX(name, x) name##_RB_MINMAX(x, RB_INF)
+
+#define RB_FOREACH(x, name, head) \
+ for ((x) = RB_MIN(name, head); \
+ (x) != NULL; \
+ (x) = name##_RB_NEXT(x))
+
+#define RB_FOREACH_FROM(x, name, y) \
+ for ((x) = (y); \
+ ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL); \
+ (x) = (y))
+
+#define RB_FOREACH_SAFE(x, name, head, y) \
+ for ((x) = RB_MIN(name, head); \
+ ((x) != NULL) && ((y) = name##_RB_NEXT(x), (x) != NULL); \
+ (x) = (y))
+
+#define RB_FOREACH_REVERSE(x, name, head) \
+ for ((x) = RB_MAX(name, head); \
+ (x) != NULL; \
+ (x) = name##_RB_PREV(x))
+
+#define RB_FOREACH_REVERSE_FROM(x, name, y) \
+ for ((x) = (y); \
+ ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL); \
+ (x) = (y))
+
+#define RB_FOREACH_REVERSE_SAFE(x, name, head, y) \
+ for ((x) = RB_MAX(name, head); \
+ ((x) != NULL) && ((y) = name##_RB_PREV(x), (x) != NULL); \
+ (x) = (y))
+
+#endif /* _BCMOS_TREE_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/bcmos_types.h b/bcm68620_release/release/host_customized/os_abstraction/bcmos_types.h
new file mode 100644
index 0000000..21f0191
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/bcmos_types.h
@@ -0,0 +1,208 @@
+/*
+<: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 BCMOS_TYPES_H_
+#define BCMOS_TYPES_H_
+
+#ifndef BCMOS_SYSTEM_H_
+#error Please do not include bcmos_types.h directly. Include bcmos_system.h
+#endif
+
+#include "bcmos_pack.h"
+
+/** \defgroup system_types Generic types
+ * @{
+ */
+
+/*
+ * Limits of integer types.
+ */
+
+/* Minimum of signed integer types. */
+#ifndef INT8_MIN
+#define INT8_MIN (0x80)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN (0x8000)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN (0x80000000)
+#endif
+#ifndef INT64_MIN
+#define INT64_MIN (0x8000000000000000)
+#endif
+
+/* Maximum of signed integer types. */
+#ifndef INT8_MAX
+#define INT8_MAX (0x7F)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (0x7FFF)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (0x7FFFFFFF)
+#endif
+#ifndef INT64_MAX
+#define INT64_MAX (0x7FFFFFFFFFFFFFFF)
+#endif
+
+/* Maximum of unsigned integer types. */
+#ifndef UINT8_MAX
+#define UINT8_MAX (0xFF)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX (0xFFFF)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX (0xFFFFFFFF)
+#endif
+#ifndef UINT64_MAX
+#define UINT64_MAX (0xFFFFFFFFFFFFFFFF)
+#endif
+
+
+/** Endianness */
+#define BCMOS_ENDIAN_BIG 0
+#define BCMOS_ENDIAN_LITTLE 1
+
+typedef enum
+{
+ BCMOS_ENDIAN_BIG_E = BCMOS_ENDIAN_BIG,
+ BCMOS_ENDIAN_LITTLE_E = BCMOS_ENDIAN_LITTLE,
+} bcmos_endian;
+
+/* If endianness is not set explicitly, try to autodetect it.
+ * Modern gcc versions (over 4.8) define __BYTE_ORDER__
+ * see "gcc -E -dM - < /dev/null | grep ENDIAN"
+ */
+#ifndef BCM_CPU_ENDIAN
+
+#ifdef __BYTE_ORDER__
+
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define BCM_CPU_ENDIAN BCMOS_ENDIAN_LITTLE
+#else
+#define BCM_CPU_ENDIAN BCMOS_ENDIAN_BIG
+#endif
+
+#else
+
+/* We are dealing with compiler that doesn't set __BYTE_ORDER__.
+ * If it is simulation build than it must be LE x86.
+ * Otherwise, no way to tell.
+ */
+#ifdef SIMULATION_BUILD
+#define BCM_CPU_ENDIAN BCMOS_ENDIAN_LITTLE
+#endif
+
+#endif /* #ifdef __BYTE_ORDER */
+
+#endif /* #ifndef BCM_CPU_ENDIAN */
+
+#include <bcm_config.h>
+
+/** 24-bit unsigned integer */
+typedef union
+{
+ uint8_t u8[3];
+ struct __PACKED_ATTR_START__
+ {
+#if (BCM_CPU_ENDIAN == BCMOS_ENDIAN_BIG)
+ uint8_t hi;
+ uint8_t mid;
+ uint8_t low;
+#elif (BCM_CPU_ENDIAN == BCMOS_ENDIAN_LITTLE)
+ uint8_t low;
+ uint8_t mid;
+ uint8_t hi;
+#else
+#error BCM_CPU_ENDIAN must be BCMOS_ENDIAN_BIG or _LITTLE
+#endif
+ } __PACKED_ATTR_END__ low_hi;
+} uint24_t;
+
+static inline uint32_t uint24_to_32(uint24_t u24)
+{
+ return (u24.low_hi.hi << 16) | (u24.low_hi.mid << 8) | u24.low_hi.low;
+}
+
+static inline uint24_t uint32_to_24(uint32_t u32)
+{
+ return (uint24_t){ .low_hi= { .hi = (u32 >> 16) & 0xff, .mid = (u32 >> 8) & 0xff, .low = u32 & 0xff } };
+}
+
+/** VLAN tag (CoS/CFI/VID) */
+typedef uint16_t bcmos_vlan_tag;
+
+#define BCMOS_ETH_ALEN 6
+
+/** MAC address */
+typedef struct
+{
+ uint8_t u8[BCMOS_ETH_ALEN];
+} bcmos_mac_address;
+
+/** IPv4 address. It is stored in network byte order. */
+typedef union
+{
+ uint32_t u32;
+ uint8_t u8[4];
+} bcmos_ipv4_address;
+
+/** IPv6 address */
+typedef uint8_t bcmos_ipv6_address[16];
+
+static inline void bcmos_mac_address_init(bcmos_mac_address *mac)
+{
+ memset(mac, 0, sizeof(*mac));
+}
+
+static inline void bcmos_ipv4_address_init(bcmos_ipv4_address *ip)
+{
+ memset(ip, 0, sizeof(*ip));
+}
+
+#ifndef CFE_BUILD
+static inline char *bcmos_inet_ntoa(bcmos_ipv4_address *ip, char *ip_str)
+{
+ snprintf(ip_str, 16, "%u.%u.%u.%u", ip->u8[0], ip->u8[1], ip->u8[2], ip->u8[3]);
+
+ return ip_str;
+}
+#endif
+
+#ifndef container_of
+#define container_of(ptr, type, member) ({ \
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+ (type *)( (long)__mptr - offsetof(type,member) );})
+#endif
+
+/** @} */
+
+#endif /* BCMOS_TYPES_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/cfe/bcmolt_model_data_cfe_ext.h b/bcm68620_release/release/host_customized/os_abstraction/cfe/bcmolt_model_data_cfe_ext.h
new file mode 100644
index 0000000..ddca9ce
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/cfe/bcmolt_model_data_cfe_ext.h
@@ -0,0 +1,92 @@
+/*
+<: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 BCMOS_MODEL_DATA_CFE_EXT_H_
+#define BCMOS_MODEL_DATA_CFE_EXT_H_
+
+#include "bcmolt_model_data.h"
+
+typedef struct
+{
+ bcmolt_system_mode system_mode;
+ bcmolt_device_nni_speed nni_speed;
+ bcmos_bool use_prev_nni_serdes_firmware;
+} db_rec_device;
+
+/* System mode */
+static bcmolt_system_mode device_system_mode;
+
+/** Set system mode
+ * \param[in] dev Device id
+ * \param[in] system_mode System mode
+ * \returns BCM_ERR_OK, BCM_ERR_NOT_SUPPORTED
+ */
+static inline bcmos_errno bcmolt_system_mode_set(uint16_t dev, bcmolt_system_mode system_mode)
+{
+ device_system_mode = system_mode;
+ return BCM_ERR_OK;
+}
+
+/** Get system mode
+ * \param[in] dev Device id
+ * \param[in] system_mode System mode
+ * \returns BCM_ERR_OK
+ */
+static inline bcmos_errno bcmolt_system_mode_get(uint16_t dev, bcmolt_system_mode *system_mode)
+{
+ *system_mode = device_system_mode;
+ return BCM_ERR_OK;
+}
+
+
+static inline int is_issu_boot(void)
+{
+ return BCMOS_FALSE;
+}
+
+
+#endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/cfe/bcmos_system.h b/bcm68620_release/release/host_customized/os_abstraction/cfe/bcmos_system.h
new file mode 100644
index 0000000..763cc79
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/cfe/bcmos_system.h
@@ -0,0 +1,138 @@
+/*
+<: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 BCMOS_SYSTEM_H_
+#define BCMOS_SYSTEM_H_
+
+#include <limits.h>
+
+#include "lib_types.h"
+#include "lib_string.h"
+
+#include "../bcmos_errno.h"
+#include "../bcmos_types.h"
+#include "../bcmos_endian.h"
+#include "cfe_timer.h"
+#include "lib_printf.h"
+
+#define bcmos_printf printf
+
+#define bcmos_usleep(x) \
+ do { \
+ cfe_usleep (x); \
+ } \
+ while(0)
+/* Define bcmos_bool - the boolean type for bcmos - based on C99 standard boolean type */
+#ifndef BCMOS_BOOLEAN
+typedef _Bool bcmos_bool;
+#define BCMOS_FALSE 0
+#define BCMOS_TRUE 1
+#endif
+
+#define PERIPH_GENINT_REVID 0xffe00000
+#define CHIP_REV_MASK 0xFF
+static inline unsigned int get_chip_revision(void)
+{
+ return *(volatile unsigned int*)PERIPH_GENINT_REVID & CHIP_REV_MASK;
+}
+
+#define CHIP_REVISION_A0 0xA0
+#define CHIP_REVISION_B0 0xB0
+
+#ifdef SIMULATION_BUILD
+#define GET_CHIP_REVISION CHIP_REVISION_A0
+#else
+extern uint32_t chip_revision;
+#define GET_CHIP_REVISION (chip_revision != 0 ? chip_revision : (chip_revision = get_chip_revision()))
+#endif
+
+
+typedef uint16_t bcmos_fastlock;
+#define BCMOS_FASTLOCK_INITIALIZER 0
+#define bcmos_fastlock_lock(fastlock) (long)fastlock
+#define bcmos_fastlock_unlock(fastlock, flags) (void)flags
+
+typedef uint16_t bcmos_mutex;
+#define bcmos_mutex_create(mutex, flags, name)
+#define bcmos_mutex_lock(mutex)
+#define bcmos_mutex_unlock(mutex)
+
+
+#define BCM_SIZEOFARRAY(arr) (sizeof(arr)/sizeof(*arr))
+#define BCM_SIZEOFFIELD(s, f) (sizeof(((s*)NULL)->f))
+#define BCM_MEMZERO_STRUCT(ptr) memset(ptr, 0, sizeof(*(ptr)))
+#define BCM_MEMCPY_ARRAY(dst, src) memcpy(dst, src, sizeof(dst))
+
+
+#define BUG_ON_PRINT(condition, fmt, args...) \
+ do \
+ { \
+ if (condition) \
+ { \
+ printf(fmt, ##args); \
+ /* On one hand, don't let this task continue - it is likely to crash/create a system exception.
+ * On the other hand, it mustn't do a busy loop - otherwise it can cause lower priority tasks to stop responding. */ \
+ while (1) \
+ bcmos_usleep(10000000); \
+ } \
+ } while (0)
+
+#define BUG_ON(condition) BUG_ON_PRINT((condition), "BUG in %s %d!\n", __FUNCTION__, __LINE__)
+#define BUG() BUG_ON(1)
+#define BUG_UNLESS(condition) BUG_ON(!(condition))
+
+
+#define BCMOS_TRACE_ERR(fmt, args...) \
+ do \
+ { \
+ printf( fmt, ## args); \
+ } while (0)
+
+
+#define bcmos_vprintf printf
+#define bcmos_calloc(s) KMALLOC((s), 0)
+
+#endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/linux/Makefile b/bcm68620_release/release/host_customized/os_abstraction/linux/Makefile
new file mode 100644
index 0000000..c66f726
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/linux/Makefile
@@ -0,0 +1,31 @@
+# Linux kernel OS abstraction
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = os_linux
+MOD_TYPE = linux_module
+MOD_SUPPRESS_OS_DEP = y
+MOD_DEPS = ll_pcie
+
+MOD_INC_DIRS = $(SRC_DIR) $(SRC_DIR)/..
+ifeq ("$(RELEASE_BUILD)", "y")
+ MOD_INC_DIRS += host_driver/config
+else
+ MOD_INC_DIRS += $(SUBSYSTEM)/os_abstraction/$(PLATFORM) $(SUBSYSTEM)/config
+endif
+
+EXTRA_CFLAGS += -DBCMOS_TRACE_PRINTF
+
+srcs = bcmos_system.c ../bcmos_errno.c ../bcmos_common.c
+
+ifeq ("$(DEBUG)", "y")
+ MOD_DEFS += -DBCMOS_MEM_DEBUG -DBCMOS_SYS_UNITTEST
+endif
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/linux/bcmos_system.c b/bcm68620_release/release/host_customized/os_abstraction/linux/bcmos_system.c
new file mode 100644
index 0000000..0b4a023
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/linux/bcmos_system.c
@@ -0,0 +1,536 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmos_system.c
+ *
+ * This file implements a subset of OS Abstraction services
+ * for linux kernel
+ */
+
+#include <bcmos_system.h>
+
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <asm-generic/pci-dma-compat.h>
+#include <linux/fs.h>
+#include <linux/fdtable.h>
+
+#include <bcmolt_llpcie.h>
+
+/* task control blocks */
+extern STAILQ_HEAD(task_list, bcmos_task) task_list;
+
+/* global OS lock */
+extern bcmos_mutex bcmos_res_lock;
+
+/* Initialize system library */
+bcmos_errno bcmos_sys_init(void)
+{
+ return BCM_ERR_OK;
+}
+/* Clean-up system library */
+void bcmos_sys_exit(void)
+{
+}
+
+/*
+ * Thread handler
+ */
+static int bcmos_task_handler(void *data)
+{
+ bcmos_task *task = (bcmos_task *)data;
+ F_bcmos_task_handler handler;
+ long handler_data;
+
+ task->sys_task.t = current;
+
+ if (task->parm.handler)
+ {
+ /* "traditional task */
+ handler = task->parm.handler;
+ handler_data = task->parm.data;
+ }
+ else
+ {
+ /* "integrated" task */
+ handler = bcmos_dft_task_handler;
+ handler_data = (long)task;
+ }
+ handler(handler_data);
+
+ return 0;
+}
+
+void _bcmos_backtrace(void)
+{
+ /*todo implement this*/
+}
+
+/* Create a new task.
+ * Attention! Priority is ignored.
+ */
+bcmos_errno bcmos_task_create(bcmos_task *task, const bcmos_task_parm *parm)
+{
+ struct task_struct *t;
+ bcmos_errno rc;
+
+ if (!task || !parm)
+ return BCM_ERR_PARM;
+
+ memset(task, 0, sizeof(*task));
+ task->parm = *parm;
+ if (!parm->handler)
+ {
+ /* Initialize and lock mutex to wait on */
+ rc = bcmos_sem_create(&task->active_sem, 0, task->parm.flags, parm->name);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Task %s: can't create active_sem. Error %s (%d)\n",
+ task->parm.name, bcmos_strerror(rc), rc);
+ return rc;
+ }
+ }
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (task->parm.name)
+ {
+ strncpy(task->name, task->parm.name, sizeof(task->name) - 1);
+ task->parm.name = task->name;
+ }
+ bcmos_fastlock_init(&task->active_lock, 0);
+ task->magic = BCMOS_TASK_MAGIC;
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&task_list, task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+
+ t = kthread_run(bcmos_task_handler, task, parm->name);
+ if (t == ERR_PTR(-ENOMEM))
+ {
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&task_list, task, bcmos_task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ task->magic = 0;
+ return BCM_ERR_NOMEM;
+ }
+
+ return BCM_ERR_OK;
+}
+
+/* Destroy task */
+bcmos_errno bcmos_task_destroy(bcmos_task *task)
+{
+ if (task->magic != BCMOS_TASK_MAGIC)
+ {
+ return BCM_ERR_PARM;
+ }
+ if (!task->sys_task.t)
+ {
+ return BCM_ERR_NOENT;
+ }
+ task->destroy_request = BCMOS_TRUE;
+ task->magic = BCMOS_TASK_MAGIC_DESTROYED;
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&task_list, task, bcmos_task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ /* The task may be waiting on semaphore. Kick it */
+ if (!task->parm.handler)
+ {
+ bcmos_sem_post(&task->active_sem);
+ }
+
+ /* Sometimes by the time we get here the task has already been disposed of.
+ * TODO: investigate why */
+ if (task->sys_task.t->cred != NULL)
+ {
+ kthread_stop(task->sys_task.t);
+ }
+ return BCM_ERR_OK;
+}
+
+/** Get current task
+ * \returns task handle or NULL if not in task context
+ */
+bcmos_task *bcmos_task_current(void)
+{
+ struct task_struct *kt = current;
+ bcmos_task *t, *tmp;
+
+ STAILQ_FOREACH_SAFE(t, &task_list, list, tmp)
+ {
+ if (t->sys_task.t == kt)
+ break;
+ }
+ return t;
+}
+
+/* timer signal handler */
+static void sys_timer_handler(unsigned long data)
+{
+ bcmos_sys_timer *timer = (bcmos_sys_timer *)data;
+ timer->handler(timer->data);
+}
+
+/* Create timer */
+bcmos_errno bcmos_sys_timer_create(bcmos_sys_timer *timer, bcmos_sys_timer_handler handler, void *data)
+{
+ if (!timer || !handler)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "timer %p, handler %p\n", timer, handler);
+
+ timer->handler = handler;
+ timer->data = data;
+ init_timer(&timer->t);
+ timer->t.function = sys_timer_handler;
+ timer->t.data = (unsigned long)timer;
+
+ return BCM_ERR_OK;
+}
+
+/* Destroy timer */
+void bcmos_sys_timer_destroy(bcmos_sys_timer *timer)
+{
+ del_timer_sync(&timer->t);
+}
+
+/* (Re)start timer */
+void bcmos_sys_timer_start(bcmos_sys_timer *timer, uint32_t delay)
+{
+ /* Convert delay us --> ticks */
+ uint32_t ticks = usecs_to_jiffies(delay);
+ mod_timer(&timer->t, jiffies + ticks);
+}
+
+/* Stop timer if running */
+void bcmos_sys_timer_stop(bcmos_sys_timer *timer)
+{
+ /* No need to do anything. System timer isn't running */
+}
+
+void bcmos_usleep(uint32_t u)
+{
+ if (u >= 10000)
+ msleep((u + 999) / 1000);
+ else
+ udelay(u);
+}
+
+/*
+ * Semaphore
+ */
+
+/* Decrement semaphore counter. Wait if the counter is 0.
+ */
+bcmos_errno bcmos_sem_wait(bcmos_sem *sem, uint32_t timeout)
+{
+ if (timeout)
+ {
+ if (timeout != BCMOS_WAIT_FOREVER)
+ {
+ if (down_timeout(&sem->s, usecs_to_jiffies(timeout)))
+ return BCM_ERR_TIMEOUT;
+ }
+ else
+ {
+ if (down_interruptible(&sem->s))
+ return BCM_ERR_INTERNAL;
+ }
+ return BCM_ERR_OK;
+ }
+
+ /* 0 timeout */
+ if (down_trylock(&sem->s))
+ {
+ return BCM_ERR_NOENT;
+ }
+ return BCM_ERR_OK;
+}
+
+
+/*
+ * Byte memory pool
+ */
+
+/* Memory block header */
+typedef struct bcmos_byte_memblk
+{
+ bcmos_byte_pool *pool; /** pool that owns the block */
+ uint32_t size; /** block size (bytes) including bcmos_byte_memblk header */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /** magic number */
+#define BCMOS_MEM_MAGIC_ALLOC (('m'<<24) | ('b' << 16) | ('l' << 8) | 'k')
+#define BCMOS_MEM_MAGIC_FREE (('m'<<24) | ('b' << 16) | ('l' << 8) | '~')
+#endif
+} bcmos_byte_memblk;
+
+/* Create byte memory pool */
+bcmos_errno bcmos_byte_pool_create(bcmos_byte_pool *pool, const bcmos_byte_pool_parm *parm)
+{
+ if (!pool || !parm)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "pool %p, parm %p\n", pool, parm);
+ }
+
+ BCM_MEMZERO_STRUCT(pool);
+ pool->parm = *parm;
+ if (!pool->parm.size)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "size %u\n", parm->size);
+ }
+#ifdef BCMOS_MEM_DEBUG
+ pool->magic = BCMOS_BYTE_POOL_VALID;
+#endif
+ return BCM_ERR_OK;
+}
+
+/* Destroy memory pool */
+bcmos_errno bcmos_byte_pool_destroy(bcmos_byte_pool *pool)
+{
+ if (pool->allocated)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_STATE, "%u bytes of memory are still allocated from the pool %s\n",
+ pool->allocated, pool->parm.name);
+ }
+#ifdef BCMOS_MEM_DEBUG
+ pool->magic = BCMOS_BYTE_POOL_DELETED;
+#endif
+ return BCM_ERR_OK;
+}
+
+/* Allocate memory from memory pool */
+void *bcmos_byte_pool_alloc(bcmos_byte_pool *pool, uint32_t size)
+{
+ bcmos_byte_memblk *blk;
+ uint32_t byte_size;
+ void *ptr;
+
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(pool->magic != BCMOS_BYTE_POOL_VALID);
+#endif
+
+ if (size + pool->allocated > pool->parm.size)
+ return NULL;
+
+ byte_size = size + sizeof(bcmos_byte_memblk);
+#ifdef BCMOS_MEM_DEBUG
+ byte_size += sizeof(uint32_t); /* block suffix */
+#endif
+ /* ToDo: Maintain LL of allocated blocks */
+ blk = (bcmos_byte_memblk *)bcmos_alloc(byte_size);
+ if (!blk)
+ return NULL;
+ ptr = (void *)(blk + 1);
+ blk->size = byte_size;
+ pool->allocated += byte_size;
+ blk->pool = pool;
+#ifdef BCMOS_MEM_DEBUG
+ blk->magic = BCMOS_MEM_MAGIC_ALLOC;
+ *(uint32_t *)((long)blk + byte_size - sizeof(uint32_t)) = BCMOS_MEM_MAGIC_ALLOC;
+#endif
+
+ return ptr;
+}
+
+/* Release memory allocated using bcmos_byte_pool_alloc() */
+void bcmos_byte_pool_free(void *ptr)
+{
+ bcmos_byte_memblk *blk;
+ bcmos_byte_pool *pool;
+
+ BUG_ON(!ptr);
+ blk = (bcmos_byte_memblk *)((long)ptr - sizeof(bcmos_byte_memblk));
+ pool = blk->pool;
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(pool->magic != BCMOS_BYTE_POOL_VALID);
+ BUG_ON(blk->magic != BCMOS_MEM_MAGIC_ALLOC);
+ BUG_ON(*(uint32_t *)((long)blk + blk->size - sizeof(uint32_t)) != BCMOS_MEM_MAGIC_ALLOC);
+ blk->magic = BCMOS_MEM_MAGIC_FREE;
+#endif
+ pool->allocated -= blk->size;
+ bcmos_free(blk);
+}
+
+/*
+ * DMA-able memory management
+ */
+
+/* Dma-able block header */
+typedef struct
+{
+ struct pci_dev *pdev;
+ dma_addr_t dma_handle;
+ uint32_t size;
+} bcmos_dma_mem_hdr;
+
+/* Allocate DMA-able memory */
+void *bcmos_dma_alloc(uint8_t device, uint32_t size)
+{
+ bcmos_dma_mem_hdr hdr =
+ {
+ .pdev = (struct pci_dev *)bcm_ll_pcie_dev_get(device),
+ .size = size
+ };
+ void *ptr;
+
+ if (!hdr.pdev)
+ {
+ return NULL;
+ }
+
+ ptr = pci_alloc_consistent(hdr.pdev, size + sizeof(bcmos_dma_mem_hdr), &hdr.dma_handle);
+ if (ptr)
+ {
+ memcpy(ptr, &hdr, sizeof(hdr));
+ }
+ return (void *)((long)ptr + sizeof(hdr));
+}
+
+/* Release DMA-able memory */
+void bcmos_dma_free(uint8_t device, void *ptr)
+{
+ bcmos_dma_mem_hdr hdr;
+
+ /* Step back to prefix area */
+ ptr = (void *)((long)ptr - sizeof(hdr));
+ memcpy(&hdr, ptr, sizeof(hdr));
+
+ /* Sanity check */
+ if (!hdr.pdev || hdr.pdev != bcm_ll_pcie_dev_get(device))
+ {
+ BCMOS_TRACE_ERR("!!!Attempt to release insane DMA-able pointer. ptr=%p pdev=%p/%p\n",
+ ptr, hdr.pdev, bcm_ll_pcie_dev_get(device));
+ return;
+ }
+ pci_free_consistent(hdr.pdev, hdr.size, ptr, hdr.dma_handle);
+}
+
+/*
+ * Print to the current process' stdout
+ */
+
+#ifndef STDOUT_FILENO
+#define STDOUT_FILENO 1
+#endif
+
+static int _bcmos_write(struct file *fd, const unsigned char *buf, int len)
+{
+ mm_segment_t oldfs;
+ int len0 = len;
+ oldfs = get_fs();
+ set_fs(KERNEL_DS);
+ while(len)
+ {
+ int lw;
+ lw = vfs_write(fd, (char *)buf, len, &fd->f_pos);
+ if (lw < 0)
+ break;
+ len -= lw;
+ if (len)
+ {
+ if (msleep_interruptible(1))
+ break;
+ buf += lw;
+ }
+ }
+ set_fs(oldfs);
+ return (len0 - len);
+}
+
+int bcmos_sys_vprintf(const char *format, va_list args)
+{
+ struct file *f;
+ int rc=0;
+
+ /* Get stdout file handle if any */
+ if (in_interrupt() || !current || !current->files)
+ f = 0;
+ else
+ f = fcheck(STDOUT_FILENO);
+ if (!f)
+ {
+ rc = vprintk(format, args);
+ }
+ else
+ {
+ char printbuf[1024];
+ char *p1=printbuf, *p2;
+ vscnprintf(printbuf, sizeof(printbuf)-1, format, args);
+ printbuf[sizeof(printbuf)-1]=0;
+ do
+ {
+ p2 = strchr(p1, '\n');
+ if (p2)
+ {
+ rc += _bcmos_write(f, (unsigned char*) p1, p2-p1+1);
+ rc += _bcmos_write(f, (unsigned char*)"\r", 1);
+ }
+ else
+ {
+ rc += _bcmos_write(f, (unsigned char*)p1, strlen(p1));
+ }
+ p1 = p2 + 1;
+ } while(p2);
+ }
+ return rc;
+}
+
+static int os_linux_module_init(void)
+{
+ bcmos_errno rc;
+
+ rc = bcmos_init();
+
+ return rc ? -EINVAL : 0;
+}
+
+static void os_linux_module_exit(void)
+{
+ bcmos_exit();
+}
+
+module_init(os_linux_module_init);
+module_exit(os_linux_module_exit);
+
+MODULE_DESCRIPTION("OS Abstraction");
+MODULE_LICENSE("Dual BSD/GPL");
+
+EXPORT_SYMBOL(bcmos_task_create);
+EXPORT_SYMBOL(bcmos_task_destroy);
+EXPORT_SYMBOL(bcmos_task_current);
+EXPORT_SYMBOL(bcmos_sem_wait);
+EXPORT_SYMBOL(bcmos_sys_trace_level);
+EXPORT_SYMBOL(bcmos_usleep);
+EXPORT_SYMBOL(bcmos_byte_pool_create);
+EXPORT_SYMBOL(bcmos_byte_pool_destroy);
+EXPORT_SYMBOL(bcmos_byte_pool_alloc);
+EXPORT_SYMBOL(bcmos_byte_pool_free);
+EXPORT_SYMBOL(bcmos_sys_vprintf);
+EXPORT_SYMBOL(bcmos_dma_alloc);
+EXPORT_SYMBOL(bcmos_dma_free);
+EXPORT_SYMBOL(_bcmos_backtrace);
+EXPORT_SYMBOL(sw_error_handler);
+EXPORT_SYMBOL(bcmos_exit);
diff --git a/bcm68620_release/release/host_customized/os_abstraction/linux/bcmos_system.h b/bcm68620_release/release/host_customized/os_abstraction/linux/bcmos_system.h
new file mode 100644
index 0000000..d6f36fe
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/linux/bcmos_system.h
@@ -0,0 +1,519 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmos_system.h
+ * Maple System Services
+ * posix port: simulation
+ */
+
+#ifndef BCMOS_SYSTEM_H_
+#define BCMOS_SYSTEM_H_
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/string.h>
+#include <linux/stddef.h>
+#include <linux/skbuff.h>
+#include <linux/mutex.h>
+#include <linux/spinlock.h>
+#include <linux/semaphore.h>
+#include <linux/interrupt.h>
+#include <linux/kthread.h>
+#include <linux/compiler.h>
+#include <linux/random.h>
+#include <linux/ctype.h>
+#include <linux/time.h>
+#include <asm/io.h>
+
+#define BCMOS_IRQ_SINGLE 0
+#define BCMOS_IRQ_SHARED IRQF_SHARED
+
+/* Re-define GNU typeof as ISO __typeof__ */
+#define typeof __typeof__
+
+#define strtol(s,p,b) simple_strtol(s,p,b)
+
+/* Specify here which system functions are inlined */
+
+#define BCMOS_FASTLOCK_INLINE
+#define BCMOS_SEM_INLINE
+#define BCMOS_MUTEX_INLINE
+
+#ifdef ENABLE_LOG
+#define BCMOS_TRACE_IN_DEV_LOG
+#endif
+
+#if !defined(BCMOS_TRACE_IN_DEV_LOG) && !defined(BCMOS_TRACE_PRINTF)
+#define BCMOS_TRACE_PRINTF
+#endif
+
+/* #define BCMOS_BYTE_POOL_ALLOC_FREE_INLINE */
+#define BCMOS_MALLOC_FREE_INLINE
+/* #define BCMOS_CALLOC_INLINE */
+#define BCMOS_BUF_OS_SPECIFIC
+#define BCMOS_BUF_INLINE
+#define BCMOS_INTERRUPT_INLINE
+#define BCMOS_TIMESTAMP_INLINE
+/* #define BCMOS_DMA_ALLOC_FREE_INLINE */
+#define BCMOS_VIRT_TO_PHYS_INLINE
+#define BCMOS_CACHE_INLINE
+/* Uncommentthe following line if h/w supports DMA cache coherency */
+/* #define BCMOS_DMA_CACHE_COHERENCY */
+
+/* getchar, putchar are not support. define as inline and proviude dummy targets */
+#define BCMOS_GETCHAR_INLINE
+#define BCMOS_PUTCHAR_INLINE
+
+#include "bcmos_common.h"
+
+static inline void bcm_pci_write32(volatile uint32_t *address, uint32_t value)
+{
+ writel(value, address);
+}
+
+static inline uint32_t bcm_pci_read32(const volatile uint32_t *address)
+{
+ return readl(address);
+}
+
+
+void _bcmos_backtrace(void);
+int bcmos_sys_vprintf(const char *format, va_list args);
+
+/*
+ * Memory allocation
+ */
+
+/* Allocate DMAable memory from the main heap */
+static inline void *bcmos_alloc(uint32_t size)
+{
+ return kmalloc(size, GFP_DMA);
+}
+
+/* Release memory to the main pool */
+static inline void bcmos_free(void *ptr)
+{
+ return kfree(ptr);
+}
+
+static inline void *bcmos_alloc_not_cache(int32_t size)
+{
+ return kmalloc(size, GFP_KERNEL);
+}
+static inline void bcmos_free_not_cache(void *dest)
+{
+ kfree(dest);
+}
+/*
+ * Synchronization
+ */
+
+/* Mutex control block */
+struct bcmos_mutex
+{
+ struct mutex m; /**< linux kernel mutex */
+};
+
+/* Create recursive mutex */
+static inline bcmos_errno bcmos_mutex_create(bcmos_mutex *mutex, uint32_t flags, const char *name)
+{
+ mutex_init(&mutex->m);
+ return BCM_ERR_OK;
+}
+
+/* Destroy mutex */
+static inline void bcmos_mutex_destroy(bcmos_mutex *mutex)
+{
+ mutex_destroy(&mutex->m);
+}
+
+/* Lock mutex */
+static inline void bcmos_mutex_lock(bcmos_mutex *mutex)
+{
+ mutex_lock(&mutex->m);
+}
+
+/* Release mutex */
+static inline void bcmos_mutex_unlock(bcmos_mutex *mutex)
+{
+ mutex_unlock(&mutex->m);
+}
+
+/** Fast lock control block */
+struct bcmos_fastlock
+{
+ spinlock_t m;
+};
+
+/** Fastlock initializer. Can be used instead of calling bcmos_fastlock_init() */
+#define BCMOS_FASTLOCK_INITIALIZER { SPINLOCK_UNLOCKED }
+
+/* Init fastlock */
+static inline void bcmos_fastlock_init(bcmos_fastlock *lock, uint32_t flags)
+{
+ spin_lock_init(&lock->m);
+}
+
+/* Take fast lock */
+static inline long bcmos_fastlock_lock(bcmos_fastlock *lock)
+{
+ unsigned long flags;
+ spin_lock_irqsave(&lock->m, flags);
+ return (long)flags;
+}
+
+/* Release fast lock */
+static inline void bcmos_fastlock_unlock(bcmos_fastlock *lock, long flags)
+{
+ spin_unlock_irqrestore(&lock->m, (unsigned long)flags);
+}
+
+/** Semaphore control block */
+struct bcmos_sem
+{
+ struct semaphore s; /**< linux kernel semaphore */
+};
+
+/* Create semaphore */
+static inline bcmos_errno bcmos_sem_create(bcmos_sem *sem, uint32_t count, uint32_t flags, const char *name)
+{
+ sema_init(&sem->s, count);
+ return BCM_ERR_OK;
+}
+
+/* Destroy semaphore */
+static inline void bcmos_sem_destroy(bcmos_sem *sem)
+{
+}
+
+/* Wait for semaphore */
+bcmos_errno bcmos_sem_wait(bcmos_sem *sem, uint32_t timeout);
+
+/* Increment semaphore counter */
+static inline void bcmos_sem_post(bcmos_sem *sem)
+{
+ up(&sem->s);
+}
+
+/*
+ * Timers
+ */
+
+/** System timer */
+struct bcmos_sys_timer
+{
+ struct timer_list t; /**< linux timer */
+ bcmos_sys_timer_handler handler; /**< Timer handler */
+ void *data; /**< Parameter to be passed to the handler */
+};
+
+/* Get current timestamp (us) */
+static inline uint32_t bcmos_timestamp(void)
+{
+ struct timespec uptime;
+ do_posix_clock_monotonic_gettime(&uptime);
+ monotonic_to_bootbased(&uptime);
+ return uptime.tv_sec * USEC_PER_SEC + uptime.tv_nsec / NSEC_PER_USEC;
+}
+
+/* Get current timestamp (us) */
+static inline uint64_t bcmos_timestamp64(void)
+{
+ struct timespec uptime;
+ do_posix_clock_monotonic_gettime(&uptime);
+ monotonic_to_bootbased(&uptime);
+ return (uint64_t)uptime.tv_sec * USEC_PER_SEC + (uint64_t)uptime.tv_nsec / NSEC_PER_USEC;
+}
+
+/*
+ * Task control
+ */
+
+/** OS-specific task control block extension */
+typedef struct bcmos_sys_task
+{
+ struct task_struct *t;
+} bcmos_sys_task;
+
+/** Memory pool control block */
+struct bcmos_byte_pool
+{
+ bcmos_byte_pool_parm parm; /**< Pool parameters */
+ uint32_t allocated; /**< Number of bytes allocated */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /**< magic number */
+#define BCMOS_BYTE_POOL_VALID (('b'<<24) | ('y' << 16) | ('p' << 8) | 'o')
+#define BCMOS_BYTE_POOL_DELETED (('b'<<24) | ('y' << 16) | ('p' << 8) | '~')
+#endif
+};
+
+/* Transport / network buffer service */
+extern uint32_t bcmos_buf_default_headroom;
+
+/*
+ * Network / transport buffer
+ */
+
+/* Data alignment. Should be a max lf L1, L2 cache line size */
+#define BCMOS_BUF_DATA_ALIGNMENT 128
+
+/* Encapsulated skb */
+struct bcmos_buf
+{
+ struct sk_buff skb;
+};
+
+/* Buffer list */
+typedef struct sk_buff_head bcmos_buf_queue;
+
+/* Allocate buffer */
+static inline bcmos_buf *bcmos_buf_alloc(uint32_t size)
+{
+ /* Allocate extra 2 * BCMOS_BUF_DATA_ALIGNMENT to make sure that neither data start nor end
+ * end up in the middle of cache line
+ */
+ struct sk_buff *skb = dev_alloc_skb(size + BCMTR_BUF_EXTRA_HEADROOM + 2 * BCMOS_BUF_DATA_ALIGNMENT - 1);
+ if (!skb)
+ return NULL;
+#if BCMTR_BUF_EXTRA_HEADROOM
+ skb_reserve(skb, BCMTR_BUF_EXTRA_HEADROOM);
+#endif
+ if ((long)skb->data & (BCMOS_BUF_DATA_ALIGNMENT - 1))
+ {
+ skb_reserve(skb, BCMOS_BUF_DATA_ALIGNMENT - ((long)skb->data & (BCMOS_BUF_DATA_ALIGNMENT - 1)));
+ }
+ return (bcmos_buf *)skb;
+}
+
+/* Release buffer */
+static inline void bcmos_buf_free(bcmos_buf *buf)
+{
+ consume_skb(&buf->skb);
+}
+
+/* Get data length */
+static inline uint32_t bcmos_buf_length(bcmos_buf *buf)
+{
+ return buf->skb.len;
+}
+
+/* Set data length */
+static inline bcmos_errno bcmos_buf_length_set(bcmos_buf *buf, uint32_t length)
+{
+ if (unlikely(length > skb_tailroom(&buf->skb)))
+ {
+ BCMOS_TRACE_ERR("!!!%s: length=%u tailroom=%d\n",
+ __FUNCTION__, length, skb_tailroom(&buf->skb));
+ return BCM_ERR_OVERFLOW;
+ }
+ buf->skb.len = length;
+ return BCM_ERR_OK;
+}
+
+/* Get buffer data pointer. */
+static inline uint8_t *bcmos_buf_data(bcmos_buf *buf)
+{
+ return buf->skb.data;
+}
+
+/* Get buffer channel. */
+static inline uint8_t bcmos_buf_channel(bcmos_buf *buf)
+{
+ return buf->skb.cb[0];
+}
+
+/* Set buffer channel. */
+static inline void bcmos_buf_channel_set(bcmos_buf *buf, uint8_t channel)
+{
+ buf->skb.cb[0] = channel;
+}
+
+/** Initialize buffer queue
+ * \param[in] q Buffer queue
+ */
+static inline void bcmos_buf_queue_init(bcmos_buf_queue *q)
+{
+ skb_queue_head_init(q);
+}
+
+/** Enqueue buffer
+ *
+ * Must be called under lock, e.g., q->lock
+ *
+ * \param[in] q Buffer queue
+ * \param[in] buf Buffer
+ */
+static inline void bcmos_buf_queue_put(bcmos_buf_queue *q, bcmos_buf *buf)
+{
+ __skb_queue_tail(q, &buf->skb);
+}
+
+/* Check if buffer queue is empty
+ * \param[in] q Buffer queue
+ * \returns TRUE if the queue is empty
+ */
+static inline bcmos_bool bcmos_buf_queue_is_empty(bcmos_buf_queue *q)
+{
+ return (bcmos_bool)skb_queue_empty(q);
+}
+
+/* Dequeue buffer
+ *
+ * Must be called under lock, e.g., q->lock
+ *
+ * Remove and return the 1st queued buffer.
+ * \param[in] q Buffer queue
+ * \returns the buffer pointer
+ */
+static inline bcmos_buf *bcmos_buf_queue_get(bcmos_buf_queue *q)
+{
+ struct sk_buff *skb = __skb_dequeue(q);
+ return skb ? container_of(skb, bcmos_buf, skb) : NULL;
+}
+
+/* Peek into queue and return the 1st buffer without dequeing it
+ *
+ * Must be called under lock, e.g., q->lock
+ * \param[in] q Buffer queue
+ * \returns the buffer pointer
+ */
+static inline bcmos_buf *bcmos_buf_queue_peek(bcmos_buf_queue *q)
+{
+ struct sk_buff *skb = skb_peek(q);
+ return skb ? container_of(skb, bcmos_buf, skb) : NULL;
+}
+
+/*
+ * dcache utilities
+ */
+/* Invalidate address area in data cache. Dirty cache lines content is discarded */
+static inline void bcmos_dcache_inv(void *start, uint32_t size)
+{
+#if defined(CONFIG_MIPS)
+ dma_cache_inv((unsigned long)start, size);
+#elif defined(CONFIG_PPC)
+ if (((unsigned long)start & (L1_CACHE_BYTES - 1)) || (size & (L1_CACHE_BYTES - 1)))
+ flush_dcache_range((unsigned long)start, (unsigned long)start + size);
+ else
+ invalidate_dcache_range((unsigned long)start, (unsigned long)start + size);
+#elif defined(CONFIG_UML)
+ /* Nothing to do */
+#else
+#error Please implement bcmos_dcache_inv()
+#endif
+}
+
+/* Flush address area in data cache. Dirty cache lines are committed to memory */
+static inline void bcmos_dcache_flush(void *start, uint32_t size)
+{
+#if defined(CONFIG_MIPS)
+ dma_cache_wback((unsigned long)start, size);
+#elif defined(CONFIG_PPC)
+ clean_dcache_range((unsigned long)start, (unsigned long)start + size);
+#elif defined(CONFIG_UML)
+ /* Nothing to do */
+#else
+#error Please implement bcmos_dcache_flush()
+#endif
+}
+
+/*
+ * Interrupt service
+ */
+
+/* Connect system interrupt */
+static inline int bcmos_int_connect(int irq, int cpu, int flags,
+ int (*isr)(int irq, void *priv), const char *name, void *priv)
+{
+ return request_irq(irq, (irq_handler_t)isr, flags, name, priv);
+}
+
+/* Disconnect system interrupt */
+static inline void bcmos_int_disconnect(int irq, void *priv)
+{
+ free_irq(irq, priv);
+}
+
+/* Unmask IRQ */
+static inline void bcmos_int_enable(int irq)
+{
+ enable_irq(irq);
+}
+
+/* Mask IRQ */
+static inline void bcmos_int_disable(int irq)
+{
+ disable_irq(irq);
+}
+
+/* Check in-irq status */
+static inline int is_irq_mode(void)
+{
+ return in_interrupt();
+}
+
+/* Check if interrupts are disabled */
+static inline int is_irq_disabled(void)
+{
+ return irqs_disabled();
+}
+
+/* Convert virtual address to physical address */
+static inline unsigned long bcmos_virt_to_phys(void *va)
+{
+ return virt_to_phys(va);
+}
+
+/* write barrier */
+static inline void bcmos_barrier(void)
+{
+ smp_wmb();
+}
+static inline int bcmos_getchar(void)
+{
+ return -1;
+}
+
+static inline void bcmos_putchar(int c)
+{
+}
+
+#ifdef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+#undef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+#endif
+
+#ifdef BCMOS_MSG_QUEUE_UDP_SOCKET
+#undef BCMOS_MSG_QUEUE_UDP_SOCKET
+#endif
+
+/* 2nd part of OS-independent declarations */
+#include "bcmos_common2.h"
+
+#endif /* BCMOS_SYSTEM_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/os_cli/Makefile b/bcm68620_release/release/host_customized/os_abstraction/os_cli/Makefile
new file mode 100644
index 0000000..545a86a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/os_cli/Makefile
@@ -0,0 +1,7 @@
+# OS CLI commands
+#
+MOD_NAME = os_cli
+MOD_TYPE = lib
+MOD_DEPS = cli
+
+srcs = bcmos_cli.c
diff --git a/bcm68620_release/release/host_customized/os_abstraction/os_cli/bcmos_cli.c b/bcm68620_release/release/host_customized/os_abstraction/os_cli/bcmos_cli.c
new file mode 100644
index 0000000..3aef31a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/os_cli/bcmos_cli.c
@@ -0,0 +1,335 @@
+/*
+<: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_cli.h>
+
+static bcmcli_entry *os_cli_dir;
+
+static bcmcli_enum_val trace_level_table[] =
+{
+ { .name="none", .val=BCMOS_TRACE_LEVEL_NONE },
+ { .name="error", .val=BCMOS_TRACE_LEVEL_ERROR },
+ { .name="info", .val=BCMOS_TRACE_LEVEL_INFO },
+ { .name="verbose_info", .val=BCMOS_TRACE_LEVEL_VERBOSE },
+ { .name="debug", .val=BCMOS_TRACE_LEVEL_DEBUG },
+ BCMCLI_ENUM_LAST
+};
+
+/*
+ * Command handlers
+ */
+
+static bcmos_errno _oscli_trace_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ bcmos_trace_level level = (bcmos_trace_level)parm[0].value.number;
+
+ if (bcmcli_parm_is_set(session, &parm[0]))
+ {
+ bcmos_trace_level old_level;
+
+ old_level = bcmos_trace_level_set(level);
+ bcmcli_session_print(session, "OS trace level: old=%s new=%s\n",
+ bcmcli_enum_stringval(trace_level_table, old_level),
+ bcmcli_enum_stringval(trace_level_table, level));
+ }
+ else
+ {
+ bcmcli_session_print(session, "OS trace level: %s\n",
+ bcmcli_enum_stringval(trace_level_table, bcmos_trace_level_get()));
+ }
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno _oscli_task_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ const char *name = bcmcli_parm_is_set(session, &parm[0]) ? (const char *)parm[0].value.string : NULL;
+ bcmos_task *task = NULL;
+ int nt = 0;
+
+ bcmcli_session_print(session, "%-20s %4s %4s %-10s %s\n", "task", "prio", "core", "timeout", "handler");
+ while (bcmos_task_get_next(&task) == BCM_ERR_OK)
+ {
+ bcmos_task_parm tp = {};
+ bcmos_task_query(task, &tp);
+ if (!name || (name && tp.name && strstr(tp.name, name)))
+ {
+ char core_name[10];
+ if (tp.core != BCMOS_CPU_CORE_ANY)
+ {
+ snprintf(core_name, sizeof(core_name), "%d", tp.core - 1);
+ }
+ else
+ {
+ strcpy(core_name, "any");
+ }
+ bcmcli_session_print(session, "%-20s %-4d %-4s %-10u %p\n",
+ tp.name, tp.priority, core_name,
+ (tp.msg_wait_timeout == BCMOS_WAIT_FOREVER) ? 0 : tp.msg_wait_timeout, tp.handler);
+ ++nt;
+ }
+ }
+ bcmcli_session_print(session, "%d tasks listed\n", nt);
+
+ return BCM_ERR_OK;
+}
+
+static void _oscli_print_qinfo_hdr(bcmcli_session *session, const char *prefix)
+{
+ bcmcli_session_print(session, "%-9s %-9s %-10s %-10s %-10s %-10s %-8s %-8s %-10s congested\n",
+ prefix ? prefix : "", "size", "in", "put", "get", "discard", "l_thresh", "h_thresh", "near-full");
+}
+
+static void _oscli_print_qinfo(bcmcli_session *session, bcmos_msg_queue_info *qi, const char *prefix)
+{
+ bcmcli_session_print(session, "%-s %-9d %-10u %-10u %-10u %-10u %-8d %-8d %-10u %s\n",
+ prefix ? prefix : "", (int)qi->parm.size, qi->stat.msg_in,
+ qi->stat.msg_sent, qi->stat.msg_received,
+ qi->stat.msg_discarded, (int)qi->parm.low_wm, (int)qi->parm.high_wm,
+ qi->stat.msg_almost_full, qi->stat.is_congested ? "yes" : "no");
+}
+
+static bcmos_errno _oscli_module_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ bcmos_module_id id = bcmcli_parm_is_set(session, &parm[0]) ?
+ (bcmos_module_id)parm[0].value.number : BCMOS_MODULE_ID_NONE;
+ bcmos_module_id i;
+ int nm = 0;
+
+ /* Heading */
+ _oscli_print_qinfo_hdr(session, "Module Task ");
+
+ for (i = BCMOS_MODULE_ID_NONE + 1; i < BCMOS_MODULE_ID__NUM_OF; i++)
+ {
+ bcmos_errno rc;
+ const bcmos_task *t = NULL;
+ bcmos_msg_queue_info qi = {};
+
+ rc = bcmos_module_query(i, &t, &qi);
+ if ((id == BCMOS_MODULE_ID_NONE || id == i) && rc == BCM_ERR_OK)
+ {
+ bcmos_task_parm tp = {};
+
+ bcmos_task_query(t, &tp);
+ bcmcli_session_print(session, "%-6d %-20s", i, (t && t->parm.name) ? t->parm.name : "*unknown*");
+ _oscli_print_qinfo(session, &qi, " ");
+ ++nm;
+ }
+ }
+ bcmcli_session_print(session, "%d modules listed\n", nm);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno _oscli_blk_pool_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ const char *name = bcmcli_parm_is_set(session, &parm[0]) ? (const char *)parm[0].value.string : NULL;
+ const bcmos_blk_pool *bp = NULL;
+ int nb = 0;
+
+ bcmcli_session_print(session, "%-24s %-9s %-9s %-9s %-10s %-10s %-10s %-10s\n",
+ "name", "pool_size", "blocks", "blk_size", "free", "allocated", "released", "failed");
+ while (bcmos_blk_pool_get_next(&bp) == BCM_ERR_OK)
+ {
+ bcmos_blk_pool_info pi = {};
+
+ bcmos_blk_pool_query(bp, &pi);
+ if (name == NULL || (pi.parm.name && strstr(pi.parm.name, name)))
+ {
+ bcmcli_session_print(session, "%-24s %-9u %-9u %-9u %-10u %-10u %-10u %-10u\n",
+ pi.parm.name ? pi.parm.name : "", pi.parm.pool_size, pi.parm.num_blks, pi.parm.blk_size,
+ pi.stat.free, pi.stat.allocated, pi.stat.released, pi.stat.alloc_failed);
+ ++nb;
+ }
+ }
+ bcmcli_session_print(session, "Total memory occupied by all block pools: %u bytes\n", bcmos_total_blk_pool_size);
+ bcmcli_session_print(session, "%d block pools listed\n", nb);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno _oscli_msg_pool_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ const char *name = bcmcli_parm_is_set(session, &parm[0]) ? (const char *)parm[0].value.string : NULL;
+ const bcmos_msg_pool *mp = NULL;
+ int np = 0;
+
+ bcmcli_session_print(session, "%-24s %-9s %-9s %-10s %-10s %-10s %-10s\n",
+ "name", "size", "data_size", "free", "allocated", "released", "failed");
+ while (bcmos_msg_pool_get_next(&mp) == BCM_ERR_OK)
+ {
+ bcmos_msg_pool_info pi = {};
+
+ bcmos_msg_pool_query(mp, &pi);
+ if (name == NULL || (pi.parm.name && strstr(pi.parm.name, name)))
+ {
+ bcmcli_session_print(session, "%-24s %-9u %-9u %-10u %-10u %-10u %-10u\n",
+ pi.parm.name ? pi.parm.name : "", pi.parm.size, pi.parm.data_size,
+ pi.stat.free, pi.stat.allocated, pi.stat.released, pi.stat.alloc_failed);
+ ++np;
+ }
+ }
+ bcmcli_session_print(session, "Total memory occupied by all message pools: %u bytes\n", bcmos_total_msg_pool_size);
+ bcmcli_session_print(session, "%d msg pools listed\n", np);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno _oscli_msg_queue_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ const char *name = bcmcli_parm_is_set(session, &parm[0]) ? (const char *)parm[0].value.string : NULL;
+ const bcmos_msg_queue *mq = NULL;
+ int nq = 0;
+
+ _oscli_print_qinfo_hdr(session, "name ");
+ while (bcmos_msg_queue_get_next(&mq) == BCM_ERR_OK)
+ {
+ bcmos_msg_queue_info qi = {};
+
+ bcmos_msg_queue_query(mq, &qi);
+ if (name == NULL || (qi.parm.name && strstr(qi.parm.name, name)))
+ {
+ bcmcli_session_print(session, "%-20s", qi.parm.name ? qi.parm.name : "");
+ _oscli_print_qinfo(session, &qi, " ");
+ ++nq;
+ }
+ }
+ bcmcli_session_print(session, "%d msg queues listed\n", nq);
+
+ return BCM_ERR_OK;
+}
+
+static void _oscli_print_qgroup_info_hdr(bcmcli_session *session)
+{
+ bcmcli_session_print(session, "%-12s %-6s %-9s %-10s %-10s %-10s %-10s %-8s %-8s %-10s congested\n",
+ "name", "queues", "size", "in", "put", "get", "discard", "l_thresh", "h_thresh", "near-full");
+}
+
+static void _oscli_print_qgroup_info(bcmcli_session *session, bcmos_msg_qgroup_info *qi)
+{
+ bcmcli_session_print(session, "%-12s %-6d %-9d %-10u %-10u %-10u %-10u %-8d %-8d %-10u %s\n",
+ qi->parm.name ? qi->parm.name : "", (int)qi->parm.nqueues, (int)qi->parm.size, qi->stat.msg_in,
+ qi->stat.msg_sent, qi->stat.msg_received,
+ qi->stat.msg_discarded, (int)qi->parm.low_wm, (int)qi->parm.high_wm,
+ qi->stat.msg_almost_full, qi->stat.is_congested ? "yes" : "no");
+}
+
+static bcmos_errno _oscli_msg_qgroup_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ const char *name = bcmcli_parm_is_set(session, &parm[0]) ? (const char *)parm[0].value.string : NULL;
+ const bcmos_msg_qgroup *qgrp = NULL;
+ int ngroups = 0;
+
+ _oscli_print_qgroup_info_hdr(session);
+ while (bcmos_msg_qgroup_get_next(&qgrp) == BCM_ERR_OK)
+ {
+ bcmos_msg_qgroup_info qi = {};
+
+ bcmos_msg_qgroup_query(qgrp, &qi);
+ if (name == NULL || (qi.parm.name && strstr(qi.parm.name, name)))
+ {
+ _oscli_print_qgroup_info(session, &qi);
+ ++ngroups;
+ }
+ }
+ bcmcli_session_print(session, "%d msg queue groups listed\n", ngroups);
+
+ return BCM_ERR_OK;
+}
+
+#ifdef BCM_OS_THREADX
+
+extern TX_THREAD __sys_shell__;
+extern TX_THREAD *__usr_shell__;
+
+static bcmos_errno _oscli_sys_handler(bcmcli_session *session, const bcmcli_cmd_parm parm[], uint16_t nparms)
+{
+ bcmcli_session_print(session, "Application CLI is suspended. Type \"suspend\" in system shell to resume\n");
+ tx_thread_resume(&__sys_shell__);
+ tx_thread_suspend(tx_thread_identify());
+ tx_thread_wait_abort(tx_thread_identify());
+ bcmcli_session_print(session, "Application CLI is resumed\n");
+ return BCM_ERR_OK;
+}
+#endif
+
+/*
+ * Init / exit interface
+ */
+
+
+bcmos_errno bcmos_cli_init(bcmcli_entry *top_dir)
+{
+ if (os_cli_dir)
+ {
+ return BCM_ERR_ALREADY;
+ }
+
+ /*
+ * rx directory
+ */
+ os_cli_dir = bcmcli_dir_add(top_dir, "os", "OS Abstraction", BCMCLI_ACCESS_GUEST, NULL);
+ BCMOS_CHECK_RETURN_ERROR(!os_cli_dir, BCM_ERR_INTERNAL);
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "trace", "Get/Set trace level", _oscli_trace_handler,
+ BCMCLI_MAKE_PARM_ENUM("level", "Trace level", trace_level_table, BCMCLI_PARM_FLAG_OPTIONAL));
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "task", "Task info", _oscli_task_handler,
+ BCMCLI_MAKE_PARM("name", "Task name or partial name", BCMCLI_PARM_STRING, BCMCLI_PARM_FLAG_OPTIONAL));
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "module", "Module(s)", _oscli_module_handler,
+ BCMCLI_MAKE_PARM_RANGE("id", "Module id", BCMCLI_PARM_NUMBER, BCMCLI_PARM_FLAG_OPTIONAL,
+ BCMOS_MODULE_ID_NONE + 1, BCMOS_MODULE_ID__NUM_OF - 1));
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "blk_pool", "Block pool(s)", _oscli_blk_pool_handler,
+ BCMCLI_MAKE_PARM("name", "Block pool name or partial name", BCMCLI_PARM_STRING, BCMCLI_PARM_FLAG_OPTIONAL));
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "msg_pool", "Message pool(s)", _oscli_msg_pool_handler,
+ BCMCLI_MAKE_PARM("name", "Message pool name or partial name", BCMCLI_PARM_STRING, BCMCLI_PARM_FLAG_OPTIONAL));
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "queue", "Message queue(s)", _oscli_msg_queue_handler,
+ BCMCLI_MAKE_PARM("name", "Message queue name or partial name", BCMCLI_PARM_STRING, BCMCLI_PARM_FLAG_OPTIONAL));
+
+ BCMCLI_MAKE_CMD(os_cli_dir, "qgroup", "Message queue group(s)", _oscli_msg_qgroup_handler,
+ BCMCLI_MAKE_PARM("name", "Message queue group name or partial name", BCMCLI_PARM_STRING, BCMCLI_PARM_FLAG_OPTIONAL));
+
+#ifdef BCM_OS_THREADX
+ BCMCLI_MAKE_CMD_NOPARM(os_cli_dir, "sys", "System shell", _oscli_sys_handler);
+#endif
+
+ return BCM_ERR_OK;
+}
+
+void bcmos_cli_exit(void)
+{
+ if (os_cli_dir)
+ {
+ bcmcli_token_destroy(os_cli_dir);
+ os_cli_dir = NULL;
+ }
+}
diff --git a/bcm68620_release/release/host_customized/os_abstraction/os_cli/bcmos_cli.h b/bcm68620_release/release/host_customized/os_abstraction/os_cli/bcmos_cli.h
new file mode 100644
index 0000000..487952c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/os_cli/bcmos_cli.h
@@ -0,0 +1,48 @@
+/*
+<: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 BCMOS_CLI_H_
+#define BCMOS_CLI_H_
+
+#include <bcmos_system.h>
+#include <bcmcli.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+bcmos_errno bcmos_cli_init(bcmcli_entry *top_dir);
+
+void bcmos_cli_exit(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* BCMOS_CLI_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/posix/bcmos_system.c b/bcm68620_release/release/host_customized/os_abstraction/posix/bcmos_system.c
new file mode 100644
index 0000000..d3cb902
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/posix/bcmos_system.c
@@ -0,0 +1,921 @@
+/*
+<: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"
+#ifdef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+#include <sys/un.h>
+#endif
+#include <sys/resource.h>
+
+/* task control blocks */
+extern STAILQ_HEAD(task_list, bcmos_task) task_list;
+
+/* global OS lock */
+extern bcmos_mutex bcmos_res_lock;
+
+/*
+ * Init
+ */
+
+#define TIMER_SIG SIGRTMIN
+
+/* Initialize system library */
+bcmos_errno bcmos_sys_init(void)
+{
+ return BCM_ERR_OK;
+}
+
+/* Clean-up system library */
+void bcmos_sys_exit(void)
+{
+}
+
+/*
+ * Task management
+ */
+
+/*
+ * Default task handler
+ */
+
+/* Create a new task */
+bcmos_errno bcmos_task_create(bcmos_task *task, const bcmos_task_parm *parm)
+{
+ F_bcmos_task_handler handler;
+ pthread_attr_t pthread_attr;
+ struct sched_param pthread_sched_param = {};
+ int pthread_prio;
+ uint32_t stack_size;
+ void *data;
+ int rc;
+
+ if (!task || !parm)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "task %p, parm %p\n", task, parm);
+ memset(task, 0, sizeof(*task));
+ if (parm->handler)
+ {
+ /* "traditional task */
+ handler = parm->handler;
+ data = (void *)parm->data;
+ }
+ else
+ {
+ /* "integrated" task */
+ handler = bcmos_dft_task_handler;
+ data = task;
+
+ /* Initialize and lock mutex to wait on */
+ rc = bcmos_sem_create(&task->active_sem, 0, task->parm.flags, parm->name);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Task %s: can't create active_sem. Error %s (%d)\n",
+ parm->name, bcmos_strerror(rc), rc);
+ return rc;
+ }
+ }
+
+ task->parm = *parm;
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (task->parm.name)
+ {
+ strncpy(task->name, task->parm.name, sizeof(task->name) - 1);
+ task->parm.name = task->name;
+ }
+ bcmos_fastlock_init(&task->active_lock, 0);
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&task_list, task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ task->magic = BCMOS_TASK_MAGIC;
+ /* pthread priorities are 1..32, 32 being the highest */
+ pthread_prio = 32 - (int)parm->priority;
+ if (pthread_prio <= 0)
+ pthread_prio = 1;
+ stack_size = PTHREAD_STACK_MIN;
+ if (parm->stack_size && parm->stack_size > PTHREAD_STACK_MIN)
+ stack_size = parm->stack_size;
+ rc = pthread_attr_init(&pthread_attr);
+ pthread_sched_param.sched_priority = pthread_prio;
+ rc = rc ? rc : pthread_attr_setinheritsched(&pthread_attr, PTHREAD_EXPLICIT_SCHED);
+ rc = rc ? rc : pthread_attr_setschedpolicy(&pthread_attr, SCHED_RR);
+ rc = rc ? rc : pthread_attr_setschedparam(&pthread_attr, &pthread_sched_param);
+ rc = rc ? rc : pthread_attr_setstacksize(&pthread_attr, stack_size);
+ rc = rc ? rc : pthread_create(&task->sys_task.t, &pthread_attr, (void *(*)(void *))handler, data);
+ pthread_attr_destroy(&pthread_attr);
+ if (rc == EPERM)
+ {
+ BCMOS_TRACE_INFO("Thread %s: priority %d is ignored. Start as root to honor priorities\n",
+ parm->name, (int)parm->priority);
+ rc = pthread_create(&task->sys_task.t, NULL, (void *(*)(void *))handler, data);
+ }
+ if (rc)
+ {
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&task_list, task, bcmos_task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ task->magic = 0;
+ if (!parm->handler)
+ {
+ bcmos_sem_destroy(&task->active_sem);
+ }
+ BCMOS_TRACE_RETURN(BCM_ERR_SYSCALL_ERR, "%s (%d)\n", strerror(rc), rc);
+ }
+ return BCM_ERR_OK;
+}
+
+/* Destroy task */
+bcmos_errno bcmos_task_destroy(bcmos_task *task)
+{
+ void *res;
+ int rc_cancel;
+ int rc;
+
+ if (task->magic != BCMOS_TASK_MAGIC)
+ {
+ return BCM_ERR_PARM;
+ }
+ task->destroy_request = BCMOS_TRUE;
+ task->magic = BCMOS_TASK_MAGIC_DESTROYED;
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&task_list, task, bcmos_task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ /* The task may be waiting on semaphore. Kick it */
+ if (!task->parm.handler)
+ {
+ bcmos_sem_post(&task->active_sem);
+ }
+ rc_cancel = pthread_cancel(task->sys_task.t);
+ rc = pthread_join(task->sys_task.t, &res);
+ return (rc || ((!rc_cancel) && (res != PTHREAD_CANCELED))) ? BCM_ERR_SYSCALL_ERR : 0;
+}
+
+/** Get current task
+ * \returns task handle or NULL if not in task context
+ */
+bcmos_task *bcmos_task_current(void)
+{
+ pthread_t pt = pthread_self();
+ bcmos_task *t, *tmp;
+
+ STAILQ_FOREACH_SAFE(t, &task_list, list, tmp)
+ {
+ if (pthread_equal(pt, t->sys_task.t))
+ break;
+ }
+ return t;
+}
+
+/*
+ * Recursive mutex
+ */
+
+/* Create recursive mutex */
+bcmos_errno bcmos_mutex_create(bcmos_mutex *mutex, uint32_t flags, const char *name)
+{
+ int err;
+ err = pthread_mutexattr_init(&mutex->attr);
+ err = err ? err : pthread_mutexattr_settype(&mutex->attr, PTHREAD_MUTEX_RECURSIVE_NP);
+ err = err ? err : pthread_mutex_init(&mutex->m, &mutex->attr);
+ if (err)
+ BCMOS_TRACE_RETURN(BCM_ERR_SYSCALL_ERR, "errno=%s\n", strerror(err));
+ return BCM_ERR_OK;
+}
+
+/** Destroy mutex
+ * \param[in] mutex Mutex control block
+ */
+void bcmos_mutex_destroy(bcmos_mutex *mutex)
+{
+ pthread_mutex_destroy(&mutex->m);
+ pthread_mutexattr_destroy(&mutex->attr);
+}
+
+/* calculate absolute time equal to the current time + timeout */
+static inline void _bcmos_get_abs_time(struct timespec *ts, uint32_t timeout)
+{
+ int rc;
+ rc = clock_gettime(CLOCK_REALTIME, ts);
+ BUG_ON(rc);
+ ts->tv_sec += timeout / 1000000;
+ ts->tv_nsec += (timeout % 1000000) * 1000;
+ if (ts->tv_nsec > 1000000000)
+ {
+ ts->tv_sec += ts->tv_nsec / 1000000000;
+ ts->tv_nsec %= 1000000000;
+ }
+}
+
+/** Lock mutex
+ */
+void bcmos_mutex_lock(bcmos_mutex *mutex)
+{
+ int rc;
+ rc = pthread_mutex_lock(&mutex->m);
+ BUG_ON(rc);
+ return;
+}
+
+/** Release mutex
+ * \param[in] mutex Mutex control block
+ */
+void bcmos_mutex_unlock(bcmos_mutex *mutex)
+{
+ int rc;
+ rc = pthread_mutex_unlock(&mutex->m);
+ if (rc)
+ BCMOS_TRACE_ERR("pthread_mutex_unlock()->%d\n", rc);
+ BUG_ON(rc);
+}
+
+/*
+ * Semaphores
+ * Most of semaphore functions are inline
+ */
+
+/* Create semaphore */
+bcmos_errno bcmos_sem_create(bcmos_sem *sem, uint32_t count, uint32_t flags, const char *name)
+{
+ sem_init(&sem->s, 0, count);
+ return BCM_ERR_OK;
+}
+
+/* Destroy semaphore */
+void bcmos_sem_destroy(bcmos_sem *sem)
+{
+ sem_destroy(&sem->s);
+}
+
+/* Decrement semaphore counter. Wait if the counter is 0 */
+bcmos_errno bcmos_sem_wait(bcmos_sem *sem, uint32_t timeout)
+{
+ int rc;
+ struct timespec ts;
+
+ /* Init end time if necessary */
+ if (timeout && timeout != BCMOS_WAIT_FOREVER)
+ {
+ _bcmos_get_abs_time(&ts, timeout);
+ }
+
+ do
+ {
+ if (timeout == BCMOS_WAIT_FOREVER)
+ {
+ rc = sem_wait(&sem->s);
+ }
+ else if (timeout)
+ {
+ rc = sem_timedwait(&sem->s, &ts);
+ }
+ else
+ {
+ rc = sem_trywait(&sem->s);
+ }
+ } while (rc && errno == EINTR);
+
+ if (rc)
+ {
+ bcmos_errno err;
+
+ rc = errno;
+ if (rc == ETIMEDOUT)
+ {
+ err = BCM_ERR_TIMEOUT;
+ }
+ else
+ {
+ err = BCM_ERR_INTERNAL;
+ BCMOS_TRACE_ERR("sem_wait()->%d\n", rc);
+ }
+ return err;
+ }
+
+ return BCM_ERR_OK;
+}
+
+
+/*
+ * Timers
+ */
+
+/** Get current timestamp
+ * \returns the current system timestamp (us)
+ */
+uint32_t bcmos_timestamp(void)
+{
+ struct timespec tp;
+ clock_gettime(CLOCK_MONOTONIC, &tp);
+ return (tp.tv_sec * 1000000 + tp.tv_nsec / 1000);
+}
+
+/** Get current timestamp - 64 bit
+ * \returns the current system timestamp (us)
+ */
+uint64_t bcmos_timestamp64(void)
+{
+ struct timespec tp;
+ clock_gettime(CLOCK_MONOTONIC, &tp);
+ return ((uint64_t)tp.tv_sec * 1000000LL + (uint64_t)tp.tv_nsec / 1000LL);
+}
+
+/*
+ * Timer handlers
+ */
+
+
+
+/* For posix we must create timer task, because there is no way
+ * to enforce protection between a signal handler and a thread
+ */
+static bcmos_task _bcmos_timer_task;
+static sem_t _bcmos_timer_lock;
+
+static int _bcmos_tmr_task_handler(long data)
+{
+ bcmos_sys_timer *timer = (bcmos_sys_timer *)data;
+ bcmos_task *this_task = bcmos_task_current();
+
+ while(!this_task->destroy_request)
+ {
+ sem_wait(&_bcmos_timer_lock);
+ timer->handler(timer->data);
+ }
+ this_task->destroyed = BCMOS_TRUE;
+
+ return 0;
+}
+
+/* timer signal handler */
+static void timer_sig_handler(int sig, siginfo_t *si, void *uc)
+{
+ BUG_ON(si->si_code != SI_TIMER);
+ sem_post(&_bcmos_timer_lock);
+}
+
+/* Create timer */
+bcmos_errno bcmos_sys_timer_create(bcmos_sys_timer *timer, bcmos_sys_timer_handler handler, void *data)
+{
+ static bcmos_task_parm tmr_task_parm = {
+ .name = "tmr_task",
+ .priority = BCMOS_TASK_PRIORITY_0,
+ .handler = _bcmos_tmr_task_handler
+ };
+ bcmos_errno rc;
+
+ struct sigaction sa;
+ struct sigevent sev = {};
+
+ if (!timer || !handler)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "timer %p, handler %p\n", timer, handler);
+
+ timer->handler = handler;
+ timer->data = data;
+
+ sem_init(&_bcmos_timer_lock, 0, 0);
+ tmr_task_parm.data = (long)timer;
+ rc = bcmos_task_create(&_bcmos_timer_task, &tmr_task_parm);
+ if (rc)
+ BCMOS_TRACE_RETURN(rc, "Can't create timer task\n");
+
+ sa.sa_flags = SA_SIGINFO;
+ sa.sa_sigaction = timer_sig_handler;
+ sigemptyset(&sa.sa_mask);
+ if (sigaction(TIMER_SIG, &sa, NULL) == -1)
+ perror("sigaction");
+ /* Prevent timer signal from interrupting system calls */
+ if (siginterrupt(TIMER_SIG, 0) == -1)
+ perror("siginterrupt");
+
+ /* Create librt timer */
+ sev.sigev_notify = SIGEV_SIGNAL;
+ sev.sigev_signo = TIMER_SIG;
+ sev.sigev_value.sival_ptr = timer;
+ if (timer_create(CLOCK_REALTIME, &sev, &timer->t) == -1)
+ BCMOS_TRACE_RETURN(BCM_ERR_SYSCALL_ERR, "errno %s\n", strerror(errno));
+
+ return BCM_ERR_OK;
+}
+
+/* Destroy timer */
+void bcmos_sys_timer_destroy(bcmos_sys_timer *timer)
+{
+ timer_delete(timer->t);
+ sem_destroy(&_bcmos_timer_lock);
+ bcmos_task_destroy(&_bcmos_timer_task);
+}
+
+/* (Re)start timer */
+void bcmos_sys_timer_start(bcmos_sys_timer *timer, uint32_t delay)
+{
+ struct itimerspec its;
+
+ its.it_value.tv_sec = delay / 1000000;
+ its.it_value.tv_nsec = (delay % 1000000) * 1000;
+ its.it_interval.tv_sec = 0;
+ its.it_interval.tv_nsec = 0;
+ if (timer_settime(timer->t, 0, &its, NULL) == -1)
+ {
+ BCMOS_TRACE_ERR("timer_settime errno %s\n", strerror(errno));
+ BUG();
+ }
+}
+
+/* Stop timer if running */
+void bcmos_sys_timer_stop(bcmos_sys_timer *timer)
+{
+ struct itimerspec its;
+
+ BUG_ON(!timer);
+ memset(&its, 0, sizeof(its));
+ timer_settime(timer->t, 0, &its, NULL);
+}
+
+
+/* Suspend current task for a time */
+void bcmos_usleep(uint32_t us)
+{
+ uint32_t ts = bcmos_timestamp();
+ uint32_t tse = ts + us;
+ int32_t d = (us > 1000000) ? 1000000 : us;
+
+ do
+ {
+ usleep(d);
+ d = tse - bcmos_timestamp();
+ if (d > 1000000) d = 1000000;
+ } while (d > 0);
+}
+
+/*
+ * Memory management
+ */
+
+/* Allocate memory from the main heap */
+void *bcmos_alloc(uint32_t size)
+{
+ return malloc(size);
+}
+
+/* Release memory to the main pool */
+void bcmos_free(void *ptr)
+{
+ free(ptr);
+}
+
+/*
+ * Byte memory pool
+ */
+
+/* Memory block header */
+typedef struct bcmos_byte_memblk
+{
+ bcmos_byte_pool *pool; /** pool that owns the block */
+ uint32_t size; /** block size (bytes) including bcmos_byte_memblk header */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /** magic number */
+#define BCMOS_MEM_MAGIC_ALLOC (('m'<<24) | ('b' << 16) | ('l' << 8) | 'k')
+#define BCMOS_MEM_MAGIC_FREE (('m'<<24) | ('b' << 16) | ('l' << 8) | '~')
+#endif
+} bcmos_byte_memblk;
+
+/* Create byte memory pool */
+bcmos_errno bcmos_byte_pool_create(bcmos_byte_pool *pool, const bcmos_byte_pool_parm *parm)
+{
+ if (!pool || !parm)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "pool %p, parm %p\n", pool, parm);
+ }
+
+ BCM_MEMZERO_STRUCT(pool);
+ pool->parm = *parm;
+ if (!pool->parm.size)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "size %u\n", parm->size);
+ }
+#ifdef BCMOS_MEM_DEBUG
+ pool->magic = BCMOS_BYTE_POOL_VALID;
+#endif
+ return BCM_ERR_OK;
+}
+
+/* Destroy memory pool */
+bcmos_errno bcmos_byte_pool_destroy(bcmos_byte_pool *pool)
+{
+ if (pool->allocated)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_STATE, "%u bytes of memory are still allocated from the pool %s\n",
+ pool->allocated, pool->parm.name);
+ }
+#ifdef BCMOS_MEM_DEBUG
+ pool->magic = BCMOS_BYTE_POOL_DELETED;
+#endif
+ return BCM_ERR_OK;
+}
+
+/* Allocate memory from memory pool */
+void *bcmos_byte_pool_alloc(bcmos_byte_pool *pool, uint32_t size)
+{
+ bcmos_byte_memblk *blk;
+ uint32_t byte_size;
+ void *ptr;
+
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(pool->magic != BCMOS_BYTE_POOL_VALID);
+#endif
+
+ if (size + pool->allocated > pool->parm.size)
+ return NULL;
+
+ byte_size = size + sizeof(bcmos_byte_memblk);
+#ifdef BCMOS_MEM_DEBUG
+ byte_size += sizeof(uint32_t); /* block suffix */
+#endif
+ /* ToDo: Maintain LL of allocated blocks */
+ blk = (bcmos_byte_memblk *)malloc(byte_size);
+ if (!blk)
+ return NULL;
+ ptr = (void *)(blk + 1);
+ blk->size = byte_size;
+ pool->allocated += byte_size;
+ blk->pool = pool;
+#ifdef BCMOS_MEM_DEBUG
+ blk->magic = BCMOS_MEM_MAGIC_ALLOC;
+ *(uint32_t *)((long)blk + byte_size - sizeof(uint32_t)) = BCMOS_MEM_MAGIC_ALLOC;
+#endif
+
+ return ptr;
+}
+
+/* Release memory allocated using bcmos_byte_pool_alloc() */
+void bcmos_byte_pool_free(void *ptr)
+{
+ bcmos_byte_memblk *blk;
+ bcmos_byte_pool *pool;
+
+ BUG_ON(!ptr);
+ blk = (bcmos_byte_memblk *)((long)ptr - sizeof(bcmos_byte_memblk));
+ pool = blk->pool;
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(pool->magic != BCMOS_BYTE_POOL_VALID);
+ BUG_ON(blk->magic != BCMOS_MEM_MAGIC_ALLOC);
+ BUG_ON(*(uint32_t *)((long)blk + blk->size - sizeof(uint32_t)) != BCMOS_MEM_MAGIC_ALLOC);
+ blk->magic = BCMOS_MEM_MAGIC_FREE;
+#endif
+ pool->allocated -= blk->size;
+ free(blk);
+}
+
+void _bcmos_backtrace(void)
+{
+ void *array[32];
+ size_t size;
+ char **strings;
+ size_t i;
+
+ size = backtrace(array, sizeof(array)/sizeof(array[0]));
+ strings = backtrace_symbols(array, size);
+
+ printf("Obtained %zd stack frames.\n", size);
+
+ for (i = 0; i < size; i++)
+ printf("%s\n", strings[i]);
+
+ free(strings);
+}
+
+/* stub for int enable */
+void bcmos_int_enable(int irq)
+{
+}
+
+void bcmos_int_disable(int irq)
+{
+}
+
+/* stub for int connect */
+int bcmos_int_connect(int irq, int cpu, int flags,
+ int (*isr)(int irq, void *priv), const char *name, void *priv)
+{
+ return 0;
+}
+
+/* Functions common for domain socket and UDP socket - based message queues */
+#if defined(BCMOS_MSG_QUEUE_DOMAIN_SOCKET) || defined(BCMOS_MSG_QUEUE_UDP_SOCKET)
+
+/** "send" to socket */
+static bcmos_errno _bcmos_socket_send(bcmos_msg_queue *queue, uint8_t *buf, uint32_t buf_length)
+{
+ int rc;
+ /* Message queue without remote endpoint address doesn't support transmit */
+ if (!queue->ep_extra_data_size)
+ return BCM_ERR_NOT_SUPPORTED;
+ rc = sendto(queue->ep, buf, buf_length, 0,
+ (struct sockaddr *)queue->ep_extra_data, queue->ep_extra_data_size);
+ return (rc == buf_length) ? BCM_ERR_OK : BCM_ERR_COMM_FAIL;
+}
+
+/** "recv" from socket */
+static bcmos_errno _bcmos_socket_recv(bcmos_msg_queue *queue, uint32_t timeout, uint8_t **buf, uint32_t *buf_length)
+{
+ int rc;
+ int wait = 0;
+
+ /* Message queue without local endpoint address doesn't support receive */
+ if (!queue->q.parm.local_ep_address)
+ return BCM_ERR_NOT_SUPPORTED;
+
+ if (timeout && timeout != BCMOS_WAIT_FOREVER)
+ {
+ fd_set read_fds;
+ struct timeval tv;
+
+ FD_ZERO(&read_fds);
+ FD_SET(queue->ep, &read_fds);
+ tv.tv_sec = timeout / 1000000;
+ tv.tv_usec = (timeout % 1000000) * 1000;
+ rc = select(queue->ep + 1, &read_fds, NULL, NULL, &tv);
+ if (rc < 0)
+ {
+ return BCM_ERR_COMM_FAIL;
+ }
+ if (!rc || !FD_ISSET(queue->ep, &read_fds))
+ return BCM_ERR_TIMEOUT;
+ wait = MSG_DONTWAIT;
+ }
+
+ rc = recv(queue->ep, queue->recv_buf, queue->q.parm.max_mtu, wait);
+ if (rc < 0)
+ {
+ return BCM_ERR_COMM_FAIL;
+ }
+ if (rc == 0)
+ return BCM_ERR_NOENT;
+
+ *buf = queue->recv_buf;
+ *buf_length = rc;
+ return BCM_ERR_OK;
+}
+
+
+static bcmos_errno _bcmos_socket_close(bcmos_msg_queue *queue)
+{
+ /* Close domain socket */
+ if (queue->ep > 0)
+ {
+ close(queue->ep);
+ }
+ if (queue->ep_extra_data)
+ {
+ bcmos_free(queue->ep_extra_data);
+ }
+ return BCM_ERR_OK;
+}
+
+
+/* Pack message for over-the-socket transmission.
+ * This function is good for case when both queue ends are on the same CPU
+ * and there is no need to do any translation.
+ */
+static bcmos_errno _bcmos_transparent_pack(bcmos_msg_queue *queue, bcmos_msg *msg, uint8_t **buf, uint32_t *buf_length)
+{
+ uint32_t size = BCMOS_MSG_HDR_SIZE + msg->size;
+
+ if (size > queue->q.parm.max_mtu)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_OVERFLOW, "Attempt to send message longer than configured max_mtu %u > %u\n",
+ size, queue->q.parm.max_mtu);
+ }
+ bcmos_msg_hdr_pack(msg, queue->send_buf, msg->size);
+ if (msg->size)
+ {
+ BUG_ON(msg->data == NULL);
+ memcpy(queue->send_buf + BCMOS_MSG_HDR_SIZE, msg->data, msg->size);
+ }
+ *buf = queue->send_buf;
+ *buf_length = size;
+ return BCM_ERR_OK;
+}
+
+/** "unpack" message. In case of domain socket both queue ends are in the same CPU.
+ * Message is sent as-is
+ */
+static bcmos_errno _bcmos_transparent_unpack(bcmos_msg_queue *queue, uint8_t *buf, uint32_t buf_length, bcmos_msg **msg)
+{
+ bcmos_msg *m;
+
+ if (buf_length < BCMOS_MSG_HDR_SIZE)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_INTERNAL, "Received message is too short (%u)\n", buf_length);
+ }
+
+ /* Adjust buf_length to account for difference in packed and unpacked message header sizes */
+ buf_length -= BCMOS_MSG_HDR_SIZE;
+ buf_length += sizeof(bcmos_msg);
+
+ m = bcmos_alloc(buf_length);
+ if (!m)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "Received message discarded: %u bytes\n", buf_length);
+ }
+
+ bcmos_msg_hdr_unpack(buf, m);
+ m->release = NULL;
+ m->data_release = NULL;
+ if (m->size != buf_length - sizeof(bcmos_msg))
+ {
+ BCMOS_TRACE_ERR("Received message is insane. Expected data length %u, got %u\n",
+ m->size, buf_length - sizeof(bcmos_msg));
+ bcmos_free(m);
+ return BCM_ERR_INTERNAL;
+ }
+ if (m->size)
+ {
+ m->data = m->start = (void *)(m + 1);
+ memcpy(m->data, &buf[BCMOS_MSG_HDR_SIZE], m->size);
+ }
+ else
+ {
+ m->data = m->start = NULL;
+ }
+ *msg = m;
+
+ return BCM_ERR_OK;
+}
+
+
+#endif
+
+/* Domain-socket-based inter-process communication */
+#ifdef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+
+bcmos_errno bcmos_sys_msg_queue_domain_socket_open(bcmos_msg_queue *queue)
+{
+ struct sockaddr_un sa;
+
+ /* Open domain socket */
+ queue->ep = socket(AF_UNIX, SOCK_DGRAM, 0);
+ if (queue->ep < 0)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Can't create domain socket. error %s\n", strerror(errno));
+ }
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sun_family = AF_UNIX;
+
+ /* If local_ep_address is set - the queue supports receive */
+ if (queue->q.parm.local_ep_address)
+ {
+ strncpy(sa.sun_path, queue->q.parm.local_ep_address, sizeof(sa.sun_path) - 1);
+ /* In linux path can start from 0 character */
+ if (!sa.sun_path[0])
+ {
+ strncpy(&sa.sun_path[1], &queue->q.parm.local_ep_address[1], sizeof(sa.sun_path) - 1);
+ }
+ if (bind(queue->ep, (struct sockaddr *)&sa, sizeof(sa)) < 0)
+ {
+ int err = errno;
+ close(queue->ep);
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Can't bind domain socket to %s. error %s\n",
+ queue->q.parm.local_ep_address, strerror(err));
+ }
+ }
+
+ /* If remote_ep_address is set - the queue supports transmit */
+ if (queue->q.parm.remote_ep_address)
+ {
+ queue->ep_extra_data = bcmos_calloc(sizeof(struct sockaddr_un));
+ if (!queue->ep_extra_data)
+ {
+ close(queue->ep);
+ return BCM_ERR_NOMEM;
+ }
+ strncpy(sa.sun_path, queue->q.parm.remote_ep_address, sizeof(sa.sun_path) - 1);
+ /* In linux path can start from 0 character */
+ if (!sa.sun_path[0])
+ {
+ strncpy(&sa.sun_path[1], &queue->q.parm.remote_ep_address[1], sizeof(sa.sun_path) - 1);
+ }
+ memcpy(queue->ep_extra_data, &sa, sizeof(sa));
+ queue->ep_extra_data_size = sizeof(sa);
+ }
+
+ /* Set callbacks */
+ queue->q.parm.close = _bcmos_socket_close;
+ queue->q.parm.send = _bcmos_socket_send;
+ queue->q.parm.recv = _bcmos_socket_recv;
+ if (!queue->q.parm.pack)
+ queue->q.parm.pack = _bcmos_transparent_pack;
+ if (!queue->q.parm.unpack)
+ queue->q.parm.unpack = _bcmos_transparent_unpack;
+
+ return BCM_ERR_OK;
+}
+
+#endif
+
+/* UDP-socket-based inter-process communication */
+#ifdef BCMOS_MSG_QUEUE_UDP_SOCKET
+
+static bcmos_errno _bcmos_parse_ip_port(const char *s, struct sockaddr_in *sa)
+{
+ uint32_t ip;
+ int n;
+ uint32_t ip1, ip2, ip3, ip4, port;
+
+ n = sscanf(s, "%u.%u.%u.%u:%u", &ip1, &ip2, &ip3, &ip4, &port);
+ if (n != 5 || ip1 > 0xff || ip2 > 0xff || ip3 > 0xff || ip4 > 0xff || port > 0xffff)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Can't parse %s. Must be ip_address:port\n", s);
+ }
+ ip = (ip1 << 24) | (ip2 << 16) | (ip3 << 8) | ip4;
+ sa->sin_port = htons(port);
+ sa->sin_addr.s_addr = htonl(ip);
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcmos_sys_msg_queue_udp_socket_open(bcmos_msg_queue *queue)
+{
+ struct sockaddr_in sa;
+ bcmos_errno rc;
+
+ /* Open UDP socket */
+ queue->ep = socket(AF_INET, SOCK_DGRAM, 0);
+ if (queue->ep < 0)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Can't create UDP socket. error %s\n", strerror(errno));
+ }
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sin_family = AF_INET;
+
+ /* If local_ep_address is set - the queue supports receive */
+ if (queue->q.parm.local_ep_address)
+ {
+ rc = _bcmos_parse_ip_port(queue->q.parm.local_ep_address, &sa);
+ if (rc)
+ return rc;
+ if (!sa.sin_addr.s_addr)
+ sa.sin_addr.s_addr = INADDR_ANY;
+ if (bind(queue->ep, (struct sockaddr *)&sa, sizeof(sa)) < 0)
+ {
+ int err = errno;
+ close(queue->ep);
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Can't bind UDP socket to %s. error %s\n",
+ queue->q.parm.local_ep_address, strerror(err));
+ }
+ }
+
+ /* If remote_ep_address is set - the queue supports transmit */
+ if (queue->q.parm.remote_ep_address)
+ {
+ rc = _bcmos_parse_ip_port(queue->q.parm.remote_ep_address, &sa);
+ if (rc)
+ return rc;
+ queue->ep_extra_data = bcmos_calloc(sizeof(sa));
+ if (!queue->ep_extra_data)
+ {
+ close(queue->ep);
+ return BCM_ERR_NOMEM;
+ }
+ memcpy(queue->ep_extra_data, &sa, sizeof(sa));
+ queue->ep_extra_data_size = sizeof(sa);
+ }
+
+ /* Set callbacks */
+ queue->q.parm.close = _bcmos_socket_close;
+ queue->q.parm.send = _bcmos_socket_send;
+ queue->q.parm.recv = _bcmos_socket_recv;
+ if (!queue->q.parm.pack)
+ queue->q.parm.pack = _bcmos_transparent_pack;
+ if (!queue->q.parm.unpack)
+ queue->q.parm.unpack = _bcmos_transparent_unpack;
+
+ return BCM_ERR_OK;
+}
+#endif
diff --git a/bcm68620_release/release/host_customized/os_abstraction/posix/bcmos_system.h b/bcm68620_release/release/host_customized/os_abstraction/posix/bcmos_system.h
new file mode 100644
index 0000000..9dc902e
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/posix/bcmos_system.h
@@ -0,0 +1,301 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmos_system.h
+ * Maple System Services
+ * posix port: simulation
+ */
+
+#ifndef BCMOS_SYSTEM_H_
+#define BCMOS_SYSTEM_H_
+
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <stdio.h>
+#include <assert.h>
+#include <stdint.h>
+#include <ctype.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <execinfo.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+/* posix port has only been tested in linux user space */
+#define LINUX_USER_SPACE
+
+/* Re-define GNU typeof as ISO __typeof__ */
+#define typeof __typeof__
+
+void _bcmos_backtrace(void);
+
+#define BUG_ON_PRINT(condition, fmt, args...) \
+ do \
+ { \
+ if (condition) \
+ { \
+ BCMOS_TRACE_ERR(fmt, ##args); \
+ assert(!(condition)); \
+ } \
+ } while (0)
+
+#define BUG_ON(condition) BUG_ON_PRINT((condition), "BUG in %s %d!\n", __FUNCTION__, __LINE__)
+#define BUG() BUG_ON(1)
+#define BUG_UNLESS(condition) BUG_ON(!(condition))
+
+/* If 'err' is not BCM_ERR_OK, there is a bug in the software - halt and print the specified message */
+#define BUG_ON_ERROR(err, fmt, args...) \
+ BUG_ON_PRINT((err) != BCM_ERR_OK, \
+ "%s:%d: err=%s (%d): " fmt, \
+ __FUNCTION__, __LINE__, bcmos_strerror(err), (err), ##args)
+
+/* Specify here which system functions are inlined */
+
+#define BCMOS_FASTLOCK_INLINE
+/* #define BCMOS_SEM_WAIT_INLINE */
+#define BCMOS_SEM_POST_INLINE
+#define BCMOS_TRACE_PRINTF
+/* #define BCMOS_BYTE_POOL_ALLOC_FREE_INLINE */
+/* #define BCMOS_MALLOC_FREE_INLINE */
+/* #define BCMOS_CALLOC_INLINE */
+#define BCMOS_DMA_ALLOC_FREE_INLINE
+#define BCMOS_VIRT_TO_PHYS_INLINE
+#define BCMOS_CACHE_INLINE
+
+#include "bcmos_common.h"
+
+/* posix-specific stuff */
+
+/*
+ * Synchronization
+ */
+
+/** \addtogroup system_mutex
+ * @{
+ */
+
+/** Mutex control block */
+struct bcmos_mutex
+{
+ pthread_mutex_t m; /**< pthread mutex */
+ pthread_mutexattr_t attr; /**< pthread mutex attribute */
+};
+
+/** @} system_mutex */
+
+/** \addtogroup system_fastlock
+ * @{
+ */
+
+/** Fast lock control block */
+struct bcmos_fastlock
+{
+ bcmos_mutex m;
+};
+
+/** Fastlock initializer. Can be used instead of calling bcmos_fastlock_init() */
+#define BCMOS_FASTLOCK_INITIALIZER { { PTHREAD_MUTEX_INITIALIZER } }
+
+/* Init fastlock */
+static inline void bcmos_fastlock_init(bcmos_fastlock *lock, uint32_t flags)
+{
+ bcmos_mutex_create(&lock->m, 0, NULL);
+}
+
+/* Take fast lock */
+static inline long bcmos_fastlock_lock(bcmos_fastlock *lock)
+{
+ bcmos_mutex_lock(&lock->m);
+ return 0;
+}
+
+/* Release fast lock */
+static inline void bcmos_fastlock_unlock(bcmos_fastlock *lock, long flags)
+{
+ bcmos_mutex_unlock(&lock->m);
+}
+
+/** @} system_fastlock */
+
+/** \addtogroup system_sem
+ * @{
+ */
+
+/** Semaphore control block */
+struct bcmos_sem
+{
+ sem_t s; /**< pthread semaphore */
+};
+
+/* Increment semaphore counter */
+static inline void bcmos_sem_post(bcmos_sem *sem)
+{
+ sem_post(&sem->s);
+}
+
+/** @} system_sem */
+
+/** \addtogroup system_timer
+ * @{
+ */
+
+/** System timer */
+struct bcmos_sys_timer
+{
+ timer_t t; /**< librt timer */
+ bcmos_sys_timer_handler handler; /**< Timer handler */
+ void *data; /**< Parameter to be passed to the handler */
+};
+
+/** @} system_timer */
+
+/** \addtogroup system_task
+ * @{
+ */
+
+/** OS-specific task control block extension */
+typedef struct bcmos_sys_task
+{
+ pthread_t t; /**< posix pthread */
+} bcmos_sys_task;
+
+/** @} system_task */
+
+/** \addtogroup byte_pool
+ * @{
+ */
+
+/** Memory pool control block */
+struct bcmos_byte_pool
+{
+ bcmos_byte_pool_parm parm; /**< Pool parameters */
+ uint32_t allocated; /**< Number of bytes allocated */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /**< magic number */
+#define BCMOS_BYTE_POOL_VALID (('b'<<24) | ('y' << 16) | ('p' << 8) | 'o')
+#define BCMOS_BYTE_POOL_DELETED (('b'<<24) | ('y' << 16) | ('p' << 8) | '~')
+#endif
+};
+
+/** @} */
+
+/* Print */
+#define bcmos_sys_vprintf(fmt, args) vprintf(fmt, args)
+
+/* A few macros to enable linux kernel space compilation */
+#define EXPORT_SYMBOL(_sym)
+
+/*
+ * The following low-level functions are mostly for simulation
+ */
+
+/*
+ * DMA-able memory allocation
+ */
+
+/* Allocate DMA-able memory */
+static inline void *bcmos_dma_alloc(uint8_t device, uint32_t size)
+{
+ return bcmos_alloc(size);
+}
+
+/* Release DMA-able memory */
+static inline void bcmos_dma_free(uint8_t device, void *ptr)
+{
+ bcmos_free(ptr);
+}
+
+/* Convert virtual address to physical address */
+static inline unsigned long bcmos_virt_to_phys(void *va)
+{
+ return (unsigned long)(va);
+}
+
+/* Invalidate address area in data cache. Dirty cache lines content is discarded. */
+static inline void bcmos_dcache_inv(void *start, uint32_t size)
+{
+}
+
+/* Flush address area in data cache. Dirty cache lines are committed to memory. */
+static inline void bcmos_dcache_flush(void *start, uint32_t size)
+{
+}
+
+/* write barrier */
+static inline void bcmos_barrier(void)
+{
+}
+
+static inline void bcm_pci_write32(volatile uint32_t *address, uint32_t value)
+{
+}
+
+static inline uint32_t bcm_pci_read32(const volatile uint32_t *address)
+{
+ return -1;
+}
+
+/* Check in-irq status */
+static inline bcmos_bool is_irq_mode(void)
+{
+ return BCMOS_FALSE;
+}
+
+/* Check if interrupts are disabled */
+static inline bcmos_bool is_irq_disabled(void)
+{
+ return BCMOS_FALSE;
+}
+
+/*
+ * Internal (to OS abstraction) functions for messaging over domain and UDP sockets
+ */
+#ifdef BCMOS_MSG_QUEUE_DOMAIN_SOCKET
+bcmos_errno bcmos_sys_msg_queue_domain_socket_open(bcmos_msg_queue *queue);
+#endif
+
+#ifdef BCMOS_MSG_QUEUE_UDP_SOCKET
+bcmos_errno bcmos_sys_msg_queue_udp_socket_open(bcmos_msg_queue *queue);
+#endif
+
+/* 2nd part of OS-independent declarations */
+#include "bcmos_common2.h"
+
+#endif /* BCMOS_SYSTEM_H_ */
diff --git a/bcm68620_release/release/host_customized/os_abstraction/vxworks55/bcmos_system.c b/bcm68620_release/release/host_customized/os_abstraction/vxworks55/bcmos_system.c
new file mode 100644
index 0000000..645c8d0
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/vxworks55/bcmos_system.c
@@ -0,0 +1,742 @@
+/*
+<: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 <vxWorks.h>
+#include <unistd.h>
+#include <taskLib.h>
+#include <wdLib.h>
+#include <sysLib.h>
+#include <errnoLib.h>
+#include <time.h>
+#include <intLib.h>
+#include <cacheLib.h>
+#include "memPartLib.h"
+
+#ifdef HOST_CPU_IS_MIPS
+#include "arch/mips/archMips.h"
+#endif
+
+#include <iv.h>
+
+#define BCMOS_DEFAULT_STACK_SIZE (100*1024)/*0x4000*/
+#define BCMOS_MICROSECONDS_TO_TICKS(u) (u)/1000000*bcmos_timer_get_frequency() + BCMOS_DIVIDE_ROUND_UP(((u)%1000000)*bcmos_timer_get_frequency(),1000000)
+
+/* task control blocks */
+extern STAILQ_HEAD(task_list, bcmos_task) task_list;
+
+/* global OS lock */
+extern bcmos_mutex bcmos_res_lock;
+
+/*
+ * Default task handler
+ */
+extern int bcmos_dft_task_handler(long data);
+
+bcmos_errno bcmos_sys_init(void)
+{
+ return BCM_ERR_OK;
+}
+
+/* Clean-up system library */
+void bcmos_sys_exit(void)
+{
+}
+
+static uint32_t bcmos_timer_get_frequency()
+{
+ static uint32_t frequency = 0;
+ if (!frequency)
+ frequency = sysClkRateGet();
+ return frequency;
+}
+
+bcmos_errno bcmos_task_create(bcmos_task *task, const bcmos_task_parm *parm)
+{
+ F_bcmos_task_handler handler;
+ void *data;
+
+ if (!task || !parm)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "task %p, parm %p\n", (void* )task, (void* )parm);
+ memset(task, 0, sizeof ( *task ));
+
+ if (parm->handler)
+ {
+ /* "traditional task */
+ handler = parm->handler;
+ data = (void *)parm->data;
+ }
+ else
+ {
+ bcmos_errno rc;
+ /* "integrated" task */
+ handler = bcmos_dft_task_handler;
+ data = task;
+
+ /* Initialize and lock mutex to wait on */
+ rc = bcmos_sem_create(&task->active_sem, 0, task->parm.flags, parm->name);
+ if (rc)
+ {
+ BCMOS_TRACE_ERR("Task %s: can't create active_sem. Error %s (%d)\n",
+ parm->name, bcmos_strerror(rc), rc);
+ return rc;
+ }
+ }
+
+ task->parm = *parm;
+ /* Copy name to make sure that it is not released - in case it was on the stack */
+ if (task->parm.name)
+ {
+ strncpy(task->name, task->parm.name, sizeof(task->name) - 1);
+ task->parm.name = task->name;
+ }
+ bcmos_fastlock_init(&task->active_lock, 0);
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_INSERT_TAIL(&task_list, task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ task->magic = BCMOS_TASK_MAGIC;
+ task->sys_task.t = taskSpawn((char*)parm->name,
+ 10 + parm->priority * 2,
+ 0,
+ parm->stack_size ? parm->stack_size : BCMOS_DEFAULT_STACK_SIZE,
+ (FUNCPTR)handler,
+ (int32_t)data,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0);
+
+ if (task->sys_task.t == ERROR)
+ {
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&task_list, task, bcmos_task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ task->magic = 0;
+ if (!parm->handler)
+ {
+ bcmos_sem_destroy(&task->active_sem);
+ }
+ BCMOS_TRACE_ERR("(%s) Error: taskSpawn, errnoGet()=%d\n", __FUNCTION__, errnoGet());
+ BUG();
+ }
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcmos_task_destroy(bcmos_task *task)
+{
+ if (task->magic != BCMOS_TASK_MAGIC)
+ {
+ return BCM_ERR_PARM;
+ }
+ task->destroy_request = BCMOS_TRUE;
+ bcmos_mutex_lock(&bcmos_res_lock);
+ STAILQ_REMOVE(&task_list, task, bcmos_task, list);
+ bcmos_mutex_unlock(&bcmos_res_lock);
+ task->magic = BCMOS_TASK_MAGIC_DESTROYED;
+ /* The task may be waiting on semaphore. Kick it */
+ if (!task->parm.handler)
+ {
+ bcmos_sem_post(&task->active_sem);
+ }
+ if (taskDelete(task->sys_task.t) != OK)
+ {
+ BCMOS_TRACE_ERR("(%s) Error: taskDelete, errnoGet()=%d\n", __FUNCTION__, errnoGet());
+ BUG();
+ }
+
+ return BCM_ERR_OK;
+}
+
+bcmos_task *bcmos_task_current(void)
+{
+ uint32_t pt = taskIdSelf();
+ bcmos_task *t, *tmp;
+
+ STAILQ_FOREACH_SAFE(t, &task_list, list, tmp)
+ {
+ if (pt == t->sys_task.t)
+ break;
+ }
+ return t;
+}
+
+void *bcmos_alloc(uint32_t size)
+{
+ return malloc(size);
+}
+
+void bcmos_free(void *ptr)
+{
+ free(ptr);
+}
+
+inline static void bcmos_sem_mutex_destroy(uint32_t sm)
+{
+ if (semDelete((SEM_ID)sm) != OK)
+ {
+ BCMOS_TRACE_ERR("(%s) Error: semDelete, errnoGet()=%d\n", __FUNCTION__, errnoGet());
+ BUG();
+ }
+}
+
+inline static bcmos_errno bcmos_sem_mutex_wait(uint32_t sm, uint32_t timeout)
+{
+ int errno;
+ STATUS status;
+
+ timeout = ((timeout == BCMOS_WAIT_FOREVER )? WAIT_FOREVER : BCMOS_MICROSECONDS_TO_TICKS(timeout));
+ status = semTake((SEM_ID)sm, timeout);
+ if (status != OK)
+ {
+ errno = errnoGet();
+ if (errno == S_objLib_OBJ_TIMEOUT)
+ {
+ return BCM_ERR_TIMEOUT;
+ }
+ BUG();
+ return BCM_ERR_INTERNAL;
+ }
+ return BCM_ERR_OK;
+}
+
+inline static void bcmos_sem_mutex_post(uint32_t sm)
+{
+ STATUS status;
+
+ status = semGive((SEM_ID)sm);
+ if (status != OK)
+ {
+ BCMOS_TRACE_ERR("(%s) Error: semGive, status=%d\n", __FUNCTION__, status);
+ BUG();
+ }
+}
+
+bcmos_errno bcmos_sem_create(bcmos_sem *sem, uint32_t count, uint32_t flags, const char *name)
+{
+ SEM_ID semaphore;
+
+ semaphore = semCCreate(SEM_Q_PRIORITY, (SEM_B_STATE)count);
+ if (semaphore == NULL)
+ {
+ BCMOS_TRACE_ERR("(%s) Error: semCCreate, errnoGet()=%d\n", __FUNCTION__, errnoGet());
+ BUG();
+ }
+ sem->s = (uint32_t)semaphore;
+
+ return BCM_ERR_OK;
+}
+
+void bcmos_sem_destroy(bcmos_sem *sem)
+{
+ bcmos_sem_mutex_destroy(sem->s);
+}
+
+bcmos_errno bcmos_sem_wait(bcmos_sem *sem, uint32_t timeout)
+{
+ return bcmos_sem_mutex_wait(sem->s, timeout);
+}
+
+void bcmos_sem_post(bcmos_sem *sem)
+{
+ bcmos_sem_mutex_post(sem->s);
+}
+
+bcmos_errno bcmos_mutex_create(bcmos_mutex *mutex, uint32_t flags, const char *name)
+{
+ SEM_ID semaphore;
+ int options;
+
+ /* SEM_INVERSION_SAFE: Enable (by default) the prevention of priority inversion problem */
+ options = SEM_Q_PRIORITY | SEM_INVERSION_SAFE;
+
+ semaphore = semMCreate(options);
+ if (semaphore == NULL)
+ {
+ BCMOS_TRACE_ERR("(%s) Error: semCCreate, errnoGet()=%d\n", __FUNCTION__, errnoGet());
+ BUG();
+ }
+
+ mutex->m = (uint32_t)semaphore;
+
+ return BCM_ERR_OK;
+}
+
+void bcmos_mutex_destroy(bcmos_mutex *mutex)
+{
+ bcmos_sem_mutex_destroy(mutex->m);
+}
+
+void bcmos_mutex_lock(bcmos_mutex *mutex)
+{
+ bcmos_sem_mutex_wait(mutex->m, BCMOS_WAIT_FOREVER);
+}
+
+void bcmos_mutex_unlock(bcmos_mutex *mutex)
+{
+ bcmos_sem_mutex_post(mutex->m);
+}
+
+void bcmos_fastlock_init(bcmos_fastlock *lock, uint32_t flags)
+{
+}
+
+long bcmos_fastlock_lock(bcmos_fastlock *lock)
+{
+ return (long)intLock();
+}
+
+void bcmos_fastlock_unlock(bcmos_fastlock *lock, long flags)
+{
+ intUnlock(flags);
+}
+
+bcmos_errno bcmos_sys_timer_create(bcmos_sys_timer *timer, bcmos_sys_timer_handler handler, void *data)
+{
+ WDOG_ID watchdog;
+
+ if (!timer || !handler)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "timer %p, handler %p\n", timer, handler);
+
+ /* Call the underlying OS */
+ watchdog = wdCreate();
+ if (watchdog == NULL)
+ BCMOS_TRACE_RETURN(BCM_ERR_SYSCALL_ERR, "errno %s\n", strerror(errno));
+
+ timer->t = (uint32_t)watchdog;
+ timer->handler = handler;
+ timer->data = data;
+
+ return BCM_ERR_OK;
+}
+
+void bcmos_sys_timer_destroy(bcmos_sys_timer *timer)
+{
+ STATUS status;
+ status = wdDelete((WDOG_ID)timer->t);
+ BCMOS_TRACE_DEBUG("wdDelete: status=%d\n", status);
+}
+
+static void _bcmos_time_handler_wrapper(long data)
+{
+ bcmos_sys_timer * timer = (bcmos_sys_timer*)data ;
+ timer->handler(timer->data);
+}
+
+void bcmos_sys_timer_start(bcmos_sys_timer *timer, uint32_t delay)
+{
+ STATUS status;
+ status = wdStart((WDOG_ID)timer->t, BCMOS_MICROSECONDS_TO_TICKS(delay), (FUNCPTR)_bcmos_time_handler_wrapper, (long)timer);
+ if (status == ERROR)
+ {
+ BCMOS_TRACE_ERR("wdStart status %d\n", status);
+ BUG();
+ }
+}
+
+void bcmos_sys_timer_stop(bcmos_sys_timer *timer)
+{
+ STATUS status;
+ status = wdCancel((WDOG_ID)timer->t);
+ if (status == ERROR)
+ {
+ BCMOS_TRACE_ERR("wdCancel status=%d\n", status);
+ BUG();
+ }
+}
+
+void bcmos_usleep(uint32_t us)
+{
+ struct timespec ts;
+
+ ts.tv_sec = us / 1000000;
+ ts.tv_nsec = ( us % 1000000 ) * 1000;
+
+ nanosleep(&ts, 0);
+}
+
+uint32_t bcmos_timestamp(void)
+{
+ struct timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ return (ts.tv_sec * 1000000 + ts.tv_nsec / 1000);
+}
+
+/** Get current timestamp - 64 bit
+ * \returns the current system timestamp (us)
+ */
+uint64_t bcmos_timestamp64(void)
+{
+ struct timespec ts;
+ clock_gettime(CLOCK_REALTIME, &ts);
+ return ((uint64_t)ts.tv_sec * 1000000LL + (uint64_t)ts.tv_nsec / 1000LL);
+}
+
+/*
+ * Byte memory pool
+ */
+
+/* Memory block header */
+typedef struct bcmos_byte_memblk
+{
+ bcmos_byte_pool *pool; /** pool that owns the block */
+ uint32_t size; /** block size (bytes) including bcmos_byte_memblk header */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /** magic number */
+#define BCMOS_MEM_MAGIC_ALLOC (('m'<<24) | ('b' << 16) | ('l' << 8) | 'k')
+#define BCMOS_MEM_MAGIC_FREE (('m'<<24) | ('b' << 16) | ('l' << 8) | '~')
+#endif
+} bcmos_byte_memblk;
+
+/* Create byte memory pool */
+bcmos_errno bcmos_byte_pool_create(bcmos_byte_pool *pool, const bcmos_byte_pool_parm *parm)
+{
+ if (!pool || !parm)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "pool %p, parm %p\n", pool, parm);
+ }
+
+ BCM_MEMZERO_STRUCT(pool);
+ pool->parm = *parm;
+ if (!pool->parm.size)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "size %u\n", parm->size);
+ }
+#ifdef BCMOS_MEM_DEBUG
+ pool->magic = BCMOS_BYTE_POOL_VALID;
+#endif
+ return BCM_ERR_OK;
+}
+
+/* Destroy memory pool */
+bcmos_errno bcmos_byte_pool_destroy(bcmos_byte_pool *pool)
+{
+ if (pool->allocated)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_STATE, "%u bytes of memory are still allocated from the pool %s\n",
+ pool->allocated, pool->parm.name);
+ }
+#ifdef BCMOS_MEM_DEBUG
+ pool->magic = BCMOS_BYTE_POOL_DELETED;
+#endif
+ return BCM_ERR_OK;
+}
+
+/* Allocate memory from memory pool */
+void *bcmos_byte_pool_alloc(bcmos_byte_pool *pool, uint32_t size)
+{
+ bcmos_byte_memblk *blk;
+ uint32_t byte_size;
+ void *ptr;
+
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(pool->magic != BCMOS_BYTE_POOL_VALID);
+#endif
+
+ if (size + pool->allocated > pool->parm.size)
+ return NULL;
+
+ byte_size = size + sizeof(bcmos_byte_memblk);
+#ifdef BCMOS_MEM_DEBUG
+ byte_size += sizeof(uint32_t); /* block suffix */
+#endif
+ /* ToDo: Maintain LL of allocated blocks */
+ blk = (bcmos_byte_memblk *)malloc(byte_size);
+ if (!blk)
+ return NULL;
+ ptr = (void *)(blk + 1);
+ blk->size = byte_size;
+ pool->allocated += byte_size;
+ blk->pool = pool;
+#ifdef BCMOS_MEM_DEBUG
+ blk->magic = BCMOS_MEM_MAGIC_ALLOC;
+ *(uint32_t *)((long)blk + byte_size - sizeof(uint32_t)) = BCMOS_MEM_MAGIC_ALLOC;
+#endif
+
+ return ptr;
+}
+
+/* Release memory allocated using bcmos_byte_pool_alloc() */
+void bcmos_byte_pool_free(void *ptr)
+{
+ bcmos_byte_memblk *blk;
+ bcmos_byte_pool *pool;
+
+ BUG_ON(!ptr);
+ blk = (bcmos_byte_memblk *)((long)ptr - sizeof(bcmos_byte_memblk));
+ pool = blk->pool;
+#ifdef BCMOS_MEM_DEBUG
+ BUG_ON(pool->magic != BCMOS_BYTE_POOL_VALID);
+ BUG_ON(blk->magic != BCMOS_MEM_MAGIC_ALLOC);
+ BUG_ON(*(uint32_t *)((long)blk + blk->size - sizeof(uint32_t)) != BCMOS_MEM_MAGIC_ALLOC);
+ blk->magic = BCMOS_MEM_MAGIC_FREE;
+#endif
+ pool->allocated -= blk->size;
+ free(blk);
+}
+
+void _bcmos_backtrace(void)
+{
+ /*todo implement this*/
+}
+
+int ffsll(long long int i)
+{
+ int l = ffs(i & 0xFFFFFFFF);
+ int h = ffs((i >> 32) & 0xFFFFFFFF);
+
+ if (l)
+ return l;
+
+ if (h)
+ return h + 32;
+
+ return 0;
+}
+
+/* stub for int enable */
+void bcmos_int_enable(int irq)
+{
+}
+
+typedef struct bcmos_int_data
+{
+ int (*isr)(int irq, void *priv);
+ int irq;
+ void *priv;
+} bcmos_int_data;
+
+static void _bcmos_int_handler(long priv)
+{
+ bcmos_int_data *data = (bcmos_int_data *)priv;
+ data->isr(data->irq, data->priv);
+}
+
+int bcmos_int_connect(int irq, int cpu, int flags, int (*isr)(int irq, void *priv), const char *name, void *priv)
+{
+ bcmos_int_data *data = bcmos_calloc(sizeof(bcmos_int_data));
+ if (!data)
+ return (int)BCM_ERR_NOMEM;
+ data->isr = isr;
+ data->irq = irq;
+ data->priv = priv;
+ return pciIntConnect(INUM_TO_IVEC(irq), _bcmos_int_handler, (long)data);
+}
+
+/* Disconnect system interrupt */
+void bcmos_int_disconnect(int irq, void *priv)
+{
+ pciIntDisconnect(INUM_TO_IVEC(irq), _bcmos_int_handler);
+}
+
+/**************************************************************
+ * Check in-irq status *
+ * related header file: "intLib.h" *
+ * param[in] none *
+ * param[out] none *
+ * return BCMOS_TRUE (1) - in interrupt context; *
+ * BCMOS_FALSE (0) - in task context; *
+ **************************************************************/
+
+bcmos_bool is_irq_mode(void)
+{
+ return intContext();
+}
+
+// from bsp
+extern int isIntDisabled();
+/**************************************************************
+ * Check if interrupts are disabled *
+ * related header file: "mipsinc.h" *
+ * param[in] none *
+ * param[out] none *
+ * return BCMOS_TRUE (1) - Gloal interrupt disable *
+ BCMOS_FALSE (0) - Gloal interrupt enable; *
+ * comment if BSP team can provide similar function, *
+ we will call it; *
+ * Another option is share this macro used on switch product *
+ *************************************************************/
+bcmos_bool is_irq_disabled(void)
+{
+ return isIntDisabled();
+}
+
+/**************************************************************
+ * write barrier *
+ * related header file: none *
+ * param[in] none *
+ * param[out] none *
+ * return none *
+ * comment:use "sync" base on MIPS (GNU style) *
+ *************************************************************/
+
+void bcmos_barrier(void)
+{
+ #if defined(HOST_CPU_IS_MIPS) || defined(HOST_CPU_IS_PPC)
+ {__asm__ __volatile__("sync");}
+ #else
+ #error HOST CPU MUST BE MIPS OR POWERPC
+ #endif
+}
+
+/**************************************************************
+ * Allocate DMA-able memory *
+ * related header file:memPartLib.h *
+ * param[in] device Device id *
+ * param[in] size Block size (bytes) *
+ * param[out] none *
+ * returns memory block pointer(uncached memory) or NULL *
+ * comment: BSP need to allocate uncached memory pool first *
+ * if BSP team can provide such function,call it directly; *
+ * suggestion: memPartCreate()create uncached memory and *
+ * return memory ID:uncachePoolMemPartId *
+ * memPartAlloc()/memPartFree():allocate/free memory via *
+ * memory ID:uncachePoolMemPartId and size *
+ * if BSP can gurantee the Memory allocated by cacheDmaMalloc *
+ * cacheDmaFree() is noncached memory,we can call them directly*
+ *************************************************************/
+
+void *bcmos_dma_alloc(uint8_t device, uint32_t size)
+{
+ void * pBuffer;
+#ifdef NON_CACHED_MEMORY_CREATED_BY_CACHEDMAMALLOC
+ pBuffer = cacheDmaMalloc(size);
+ return (pBuffer);
+#else
+ pBuffer = (void *)memPartAlloc(uncachePoolMemPartId, size));
+ return (pBuffer);
+#endif
+}
+
+/**************************************************************
+ * Release DMA-able memory *
+ * related header file: memPartLib.h *
+ * param[in] device Device id *
+ * param[in] ptr Block pointer *
+ * param[out] none *
+ * return none *
+ * comment: see above *
+ *************************************************************/
+void bcmos_dma_free(uint8_t device, void *ptr)
+{
+#ifdef NON_CACHED_MEMORY_CREATED_BY_CACHEDMAMALLOC
+ cacheDmaFree((void *)(ptr));
+#else
+ memPartFree(uncachePoolMemPartId,ptr);
+#endif
+ return;
+}
+
+/**************************************************************
+ * Convert virtual address to physical address *
+ * related header file:for MIPS CPU archMips.h *
+ * param[in] va Virtual address *
+ * return - physical address va is mapped to *
+**************************************************************/
+unsigned long bcmos_virt_to_phys(void *va)
+{
+#ifdef HOST_CPU_IS_MIPS
+ return (unsigned long)(K0_TO_PHYS(va));
+
+#else
+ /* this is an just an example,
+ if you are not working with mips make sure you define the correct mapping for your system */
+ return (unsigned long)(va);
+#endif
+}
+
+/**************************************************************
+ * Invalidate address area in data cache. *
+ * related header file: cacheLib.h *
+ * param[in] start Address area start *
+ * param[in] size Address area size *
+ * return none *
+ **************************************************************/
+void bcmos_dcache_inv(void *start, uint32_t size)
+{
+ cacheInvalidate(DATA_CACHE,start, size);
+ return;
+}
+
+/**************************************************************
+ * Flush address area in data cache. *
+ * related header file: cacheLib.h *
+ * param[in] start Address area start *
+ * param[in] size Address area size *
+ * return none *
+**************************************************************/
+void bcmos_dcache_flush(void *start, uint32_t size)
+{
+ cacheFlush(DATA_CACHE,start, size);
+ return;
+}
+
+/**************************************************************
+ * write value to PCI memory *
+ * related header file: bcmos_common2.h *
+ * param[in] address pointer to Address *
+ * param[in] value value *
+ * return none *
+ * Comment re-use BCMOS_ENDIAN_CPU_TO_LITTLE_U32 which is from*
+ * bcmos_common2.h,by this macro,can support both big endian *
+ * host and little endian host.move PCI access functions after*
+ * bcmos_common2.h *
+ **************************************************************/
+void bcm_pci_write32(volatile uint32_t *address, uint32_t value)
+{
+#ifdef HOST_PCIE_SWAP_NEEDED
+ value = BCMOS_ENDIAN_CPU_TO_LITTLE_U32(value);
+#endif
+ *address = value;
+}
+
+/**************************************************************
+ * read value to PCI memory *
+ * related header file: bcmos_common2.h *
+ * param[in] address pointer to Address *
+ * return value *
+ * Comment see above *
+**************************************************************/
+uint32_t bcm_pci_read32(const volatile uint32_t *address)
+{
+ uint32_t value;
+ value = *address;
+#ifdef HOST_PCIE_SWAP_NEEDED
+ value = BCMOS_ENDIAN_LITTLE_TO_CPU_U32(value);
+#endif
+ return value;
+
+}
+
+
diff --git a/bcm68620_release/release/host_customized/os_abstraction/vxworks55/bcmos_system.h b/bcm68620_release/release/host_customized/os_abstraction/vxworks55/bcmos_system.h
new file mode 100644
index 0000000..5633e28
--- /dev/null
+++ b/bcm68620_release/release/host_customized/os_abstraction/vxworks55/bcmos_system.h
@@ -0,0 +1,184 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmos_system.h
+ * Maple System Services
+ * vxWorks 5.5 port
+ */
+
+#ifndef BCMOS_SYSTEM_H_
+#define BCMOS_SYSTEM_H_
+
+#define BCMOS_IRQ_SINGLE 0
+#define BCMOS_IRQ_SHARED 1
+
+#define inline __inline
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+#include <time.h>
+#include <limits.h>
+#include <unistd.h>
+#include <sockLib.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+
+/* Re-define GNU typeof as ISO __typeof__ */
+#define typeof __typeof__
+
+/* Specify here which system functions are inlined */
+
+/* #define BCMOS_FASTLOCK_INLINE */
+/* #define BCMOS_SEM_WAIT_INLINE */
+/* #define BCMOS_SEM_POST_INLINE */
+/* #define BCMOS_USLEEP_INLINE */
+#define BCMOS_TRACE_PRINTF
+#define BCMOS_BYTE_POOL_ALLOC_FREE_INLINE
+/* #define BCMOS_MALLOC_FREE_INLINE */
+/* #define BCMOS_CALLOC_INLINE */
+/* if Host cpu is MIPS cpu,enable this macro */
+/* Host cpu type will be determined during compile*/
+//#define HOST_CPU_IS_MIPS
+//#define HOST_CPU_IS_PPC
+/*if the Memory allocated by cacheDmaMalloc/acheDmaFree() is non-cached memory,enable this macro*/
+#define NON_CACHED_MEMORY_CREATED_BY_CACHEDMAMALLOC
+/* Uncommentthe following line if h/w supports DMA cache coherency */
+/* #define BCMOS_DMA_CACHE_COHERENCY */
+
+static inline void bcmos_int_disable(int irq)
+{}
+
+void _bcmos_backtrace(void);
+
+#define BUG_ON(_f) do { if (_f) { _bcmos_backtrace(); } } while (0)
+#define BUG() BUG_ON(1)
+#define BUG_UNLESS(_f) BUG_ON(!(_f))
+
+/** Boolean */
+#define BCMOS_BOOLEAN
+typedef enum
+{
+ BCMOS_FALSE = 0,
+ BCMOS_TRUE = 1,
+} bcmos_bool;
+
+#include "bcmos_common.h"
+
+#define ffs(n) ffsLsb(n)
+
+/** Semaphore control block */
+struct bcmos_sem
+{
+ uint32_t s;
+};
+
+
+/** Mutex control block */
+struct bcmos_mutex
+{
+ uint32_t m;
+};
+
+/** Fast lock control block */
+struct bcmos_fastlock
+{
+ uint32_t l;
+};
+
+/** Fastlock initializer. Can be used instead of calling bcmos_fastlock_init() */
+#define BCMOS_FASTLOCK_INITIALIZER { 0 }
+
+/** OS-specific task control block extension */
+typedef struct bcmos_sys_task
+{
+ uint32_t t; /**< vxWorks task ID */
+} bcmos_sys_task;
+
+
+/** System timer */
+struct bcmos_sys_timer
+{
+ uint32_t t; /**< VxW timer */
+ bcmos_sys_timer_handler handler; /**< Timer handler */
+ void *data; /**< Parameter to be passed to the handler */
+};
+
+/** Byte memory pool control block */
+struct bcmos_byte_pool
+{
+ bcmos_byte_pool_parm parm; /**< Pool parameters */
+ uint32_t allocated; /**< Number of bytes allocated */
+#ifdef BCMOS_MEM_DEBUG
+ uint32_t magic; /**< magic number */
+#define BCMOS_BYTE_POOL_VALID (('b'<<24) | ('y' << 16) | ('p' << 8) | 'o')
+#define BCMOS_BYTE_POOL_DELETED (('b'<<24) | ('y' << 16) | ('p' << 8) | '~')
+#endif
+};
+
+#define bcmos_sys_vprintf(fmt, args) vprintf(fmt, args)
+
+#define EXPORT_SYMBOL(_sym)
+
+/* 2nd part of OS-independent declarations */
+#include "bcmos_common2.h"
+
+void bcm_pci_write32(volatile uint32_t *address, uint32_t value);
+uint32_t bcm_pci_read32(const volatile uint32_t *address);
+
+
+/*todo must check validity that the string is numeric, sscanf cannot detect errors,
+ * if not valid, put (*tailptr) in the first non valid char in string,
+ if valid, point tailptr in the last char in string (*tailptr=string+strlen(string))*/
+#define strtoull(string,tailptr,base) ({\
+ unsigned long long int __a;\
+ *(tailptr)=(char*)((string)+strlen(string));\
+ sscanf(string, base == 10 ? "%llu" : "%llx", &__a );\
+ __a;\
+ })
+#define strtoll(string,tailptr,base) ({\
+ long long int __a;\
+ *(tailptr)=(char*)((string)+strlen(string));\
+ sscanf(string,"%lld", &__a );\
+ __a;\
+ })
+
+#define snprintf(s1,n,s2,args...) sprintf(s1, s2,## args)
+#define vsnprintf(s1,n,s2,args...) vsprintf(s1, s2,## args)
+
+
+int ffsLsb (UINT32 i);
+int ffsll(long long int i);
+
+
+#endif /* BCMOS_SYSTEM_H_ */
diff --git a/bcm68620_release/release/host_customized/pcie/Makefile b/bcm68620_release/release/host_customized/pcie/Makefile
new file mode 100755
index 0000000..338d3cc
--- /dev/null
+++ b/bcm68620_release/release/host_customized/pcie/Makefile
@@ -0,0 +1,24 @@
+# PCIE driver
+# host specific
+#
+MOD_NAME = pcie_mod
+MOD_DEPS = pcie
+
+MOD_SUPPRESS_OS_DEP = y
+
+ifeq ("$(OS_KERNEL)", "linux")
+ MOD_TYPE = linux_lib
+ srcs = bcmolt_tr_pcie_specific.c
+else
+ MOD_TYPE = lib
+endif
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+USE_LINT = yes
+
+
diff --git a/bcm68620_release/release/host_customized/pcie/bcmolt_tr_pcie_specific.c b/bcm68620_release/release/host_customized/pcie/bcmolt_tr_pcie_specific.c
new file mode 100755
index 0000000..94102bc
--- /dev/null
+++ b/bcm68620_release/release/host_customized/pcie/bcmolt_tr_pcie_specific.c
@@ -0,0 +1,106 @@
+/*
+<: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 "bcmtr_pcie.h"
+#include "bcmolt_tr_pcie_specific.h"
+
+extern f_bcmtr_int bcmtr_pcie_rx_irq_handler;
+extern f_bcmtr_int bcmtr_pcie_tx_irq_handler;
+static bcmos_fastlock isr_lock;
+
+/***************************************************************/
+/* need to pass thru all the devices - check if irq is SHARED */
+/***************************************************************/
+static int bcmtr_rx_isr(int irq, void *isr_info)
+{
+ uint32_t isr_reg;
+ uint32_t mask_reg;
+ long flags;
+ int handled = 0;
+ bcm_pcied_isr_data *isr_data = (bcm_pcied_isr_data *)isr_info;
+
+ flags = bcmos_fastlock_lock(&isr_lock);
+
+ isr_reg = bcm_pci_read32((uint32_t*)(isr_data->pcie_reg_base + DMA_INTR_STATUS));
+ mask_reg = ~bcm_pci_read32((uint32_t*)(isr_data->pcie_reg_base + DMA_INTR_MASK_STATUS));
+
+ if ((isr_reg & mask_reg)& DMA_TX_DONE_MASK)
+ {
+ /* handle TX DONE interrupt */
+ isr_data->tx_done_num++;
+
+ if (bcmtr_pcie_tx_irq_handler)
+ bcmtr_pcie_tx_irq_handler(isr_data->device);
+
+ handled = 1;
+ }
+
+ if ((isr_reg & mask_reg ) & DMA_RX_DONE_MASK)
+ {
+ /* handle RX DONE interrupt */
+ isr_data->rx_done_num++;
+
+ if (bcmtr_pcie_rx_irq_handler)
+ bcmtr_pcie_rx_irq_handler(isr_data->device);
+
+ handled = 1;
+ }
+
+ if (isr_reg & (DMA_RX_ERROR_MASK | DMA_TX_ERROR_MASK))
+ {
+ if (isr_reg & DMA_RX_ERROR_MASK)
+ isr_data->rx_err_num++;
+ if (isr_reg & DMA_TX_ERROR_MASK)
+ isr_data->tx_err_num++;
+ /* clear interrupt error interrupt */
+ bcm_pci_write32((uint32_t*)(isr_data->pcie_reg_base + DMA_INTR_CLEAR), DMA_RX_ERROR_MASK | DMA_TX_ERROR_MASK);
+ handled = 1;
+ }
+
+ bcmos_fastlock_unlock(&isr_lock, flags);
+
+ return handled;
+}
+
+void bcmtr_connect_isr(void *isr_info)
+{
+ uint32_t flags = 0;
+
+ bcm_pcied_isr_data *isr_data = (bcm_pcied_isr_data *)isr_info;
+ bcmos_fastlock_init(&isr_lock, flags);
+ /* connect interrupt to system cpu - 0 */
+ bcmos_int_connect((int)isr_data->rx_irq, 0, BCMOS_IRQ_SHARED, bcmtr_rx_isr, "dmaisr", isr_data);
+}
+
+#ifdef __KERNEL__
+EXPORT_SYMBOL(bcmtr_connect_isr);
+#endif
+
+
diff --git a/bcm68620_release/release/host_customized/pcie/bcmolt_tr_pcie_specific.h b/bcm68620_release/release/host_customized/pcie/bcmolt_tr_pcie_specific.h
new file mode 100644
index 0000000..c8c8ac1
--- /dev/null
+++ b/bcm68620_release/release/host_customized/pcie/bcmolt_tr_pcie_specific.h
@@ -0,0 +1,113 @@
+/*
+<: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_TR_PCIE_SPECIFIC_H_
+#define BCMOLT_TR_PCIE_SPECIFIC_H_
+
+#include "bcmos_system.h"
+#include "bcmtr_pcie.h"
+
+#define DESCRIPTOR_CONTROL 0x00064410 /* Tx Software Descriptor List Control and Status */
+#define WAKEUP_DMA 0x00064414 /* Tx Wake Control */
+#define ERROR_STATUS 0x00064418 /* Tx Engine Error Status */
+
+#define INTR2_PCI_STATUS 0x00064318 /* PCI interrupt Status Register */
+
+#define DMA_TX_SW_DESC_LIST_CTRL_STS_TX_DMA_RUN_STOP_MASK 0x00000001
+#define DMA_TX_WAKE_CTRL_WAKE_MASK 0x00000001
+
+#define DMA_INTR_STATUS 0x00064318 /* PCI interrupt Status Register */
+#define DMA_INTR_CLEAR 0x00064320 /* PCI interrupt Clear Register */
+#define DMA_INTR_MASK_SET 0x00064328 /* PCI interrupt Mask Set Register */
+#define DMA_INTR_MASK_CLEAR 0x0006432c /* PCI interrupt Mask Clear Register */
+#define DMA_INTR_MASK_STATUS 0x00064324 /* PCI interrupt Mask & Status Register */
+
+#define DMA_RX_ERROR_MASK 0x00000008
+#define DMA_RX_DONE_MASK 0x00000004
+#define DMA_TX_DONE_MASK 0x00000001
+#define DMA_TX_ERROR_MASK 0x00000002
+
+#define PCIE_L2_INTR_MASK 0x00000020 /* L2 interrupt bit in L1 interrupt status */
+
+#define DMA_INTR1_STATUS 0x00069300 /* Interrupt Status Register */
+#define DMA_INTR1_MASK_CLEAR 0x0006930c /* Interrupt Mask Clear Register */
+#define DMA_INTR1_MASK_SET 0x00069308 /* Interrupt Mask Set Register */
+#define DMA_INTA_MASK 0x00000002
+#define DMA_INTA_SHIFT 1
+#define PCIE_STATUS_OFFSET 0x00064068 /* PCIE_PCIE_PCIE_0_PCIE_PCIE_0_MISC_PCIE_STATUS */
+
+void bcmtr_connect_isr(void *isr_info);
+
+/* first parameter is the dest PD, the second parameter is the source field */
+static inline void bcmtr_set_dest_buffer_address(uint32_t *pd, void *value)
+{
+ uint64_t tmp = bcmos_virt_to_phys(value);
+
+ bcm_pci_write32(&pd[PCI_PACKET_LOW_INDEX], (uint32_t)( tmp & 0xffffffffUL));
+ bcm_pci_write32(&pd[PCI_PACKET_HIGH_INDEX], (uint32_t)((tmp >> 32) & 0xffffffffUL));
+}
+
+/* first parameter is the dest PD, the second parameter is the source field */
+static inline void bcmtr_set_source_buffer_address(uint32_t *pd, void *value)
+{
+ uint64_t tmp = bcmos_virt_to_phys(value);
+
+ bcm_pci_write32(&pd[PCI_PACKET_LOW_INDEX], (uint32_t)( tmp & 0xffffffffUL));
+ bcm_pci_write32(&pd[PCI_PACKET_HIGH_INDEX], (uint32_t)((tmp >> 32) & 0xffffffffUL));
+}
+
+static inline bcmos_errno bcmtr_create_tu_rings(uint32_t txlength, uint32_t rxlength,
+ void **txptr, void **rxptr,
+ void **txptr_orig, void **rxptr_orig,
+ unsigned long pcie_reg_base)
+{
+ *txptr = NULL;
+ *rxptr_orig = NULL;
+ *txptr = NULL;
+ *rxptr_orig = NULL;
+
+ return BCM_ERR_OK;
+}
+static inline void bcmtr_pcie_specific_init(unsigned long pcie_reg_base) {}
+static inline void bcmtr_pcie_free_rings(uint32_t device, uint32_t *tx_ptr, uint32_t * rx_ptr){}
+static inline void bcmtr_pcie_free_irq(uint32_t irq, void *priv)
+{
+#ifndef SIMULATION_BUILD
+ bcmos_int_disconnect((int)irq, priv);
+#endif
+}
+
+#define TX_LOCKDEF bcmos_mutex tx_lock;
+#define CREATE_TXLOCK(i) bcmos_mutex_create(&bcmtr_pcie_data[i].tx_lock, 0, NULL)
+#define DESTROY_TXLOCK(i) bcmos_mutex_destroy(&bcmtr_pcie_data[i].tx_lock)
+#define LOCK_TX() bcmos_mutex_lock(¤t_device->tx_lock)
+#define UNLOCK_TX() bcmos_mutex_unlock(¤t_device->tx_lock)
+
+#endif
+
diff --git a/bcm68620_release/release/host_customized/transport/nl_socket/Makefile b/bcm68620_release/release/host_customized/transport/nl_socket/Makefile
new file mode 100644
index 0000000..7e85eb0
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/nl_socket/Makefile
@@ -0,0 +1,22 @@
+# NL transport driver
+#
+ifeq ("$(OS_KERNEL)", "linux")
+ifeq ("$(CONFIG_TRANSPORT_RAW)", "y")
+
+
+MOD_NAME = nltr
+MOD_TYPE = linux_lib
+MOD_DEPS = trmux tr_plugin_raw
+
+srcs = bcmolt_tr_nl_driver.c
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+USE_LINT = yes
+
+endif
+endif
diff --git a/bcm68620_release/release/host_customized/transport/nl_socket/bcmolt_tr_nl_driver.c b/bcm68620_release/release/host_customized/transport/nl_socket/bcmolt_tr_nl_driver.c
new file mode 100644
index 0000000..a63fca2
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/nl_socket/bcmolt_tr_nl_driver.c
@@ -0,0 +1,232 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * nl_transport.c
+ *
+ * NL-socket based transport. Kernel space module
+ *
+ */
+#include <linux/module.h> /* Needed by all modules */
+#include <linux/kernel.h> /* Needed for KERN_INFO */
+#include <net/netlink.h>
+#include <net/sock.h>
+#include <linux/netdevice.h>
+#include <linux/version.h>
+
+#include <bcmolt_tr_mux.h>
+#include <bcmolt_tr_nl_driver.h>
+#include "bcmolt_tr_nl.h"
+
+#define BCMTR_MEM_PACKETS 10000
+#define BCMTR_MEM_OVERHEAD SKB_TRUESIZE(1024)
+#define BCMTR_MIN_RCVBUF_SIZE (BCMTR_MEM_PACKETS * BCMTR_MEM_OVERHEAD)
+
+struct sock *bcmtr_nl_sock = NULL;
+
+/* Netlink operations. This driver overrides a couple */
+static struct proto_ops bcmtr_nl_ops;
+static int (*netlink_release_org)(struct socket *sock);
+
+struct bcmtr_nl
+{
+ bcmtrmux_channel channel[BCMTR_MAX_OLTS];
+ int pid;
+ struct sock *sk;
+};
+
+static int bcmtr_netlink_release(struct socket *sock)
+{
+ struct sock *sk = sock->sk;
+ struct bcmtr_nl *nlb = sk->sk_user_data;
+ if (nlb)
+ {
+ int i;
+ for (i = 0; i < BCMTR_MAX_OLTS; i++)
+ {
+ if (nlb->channel[i])
+ bcmtrmux_channel_unregister(i, nlb->channel[i]);
+ }
+ kfree(nlb);
+ sk->sk_user_data = NULL;
+ }
+ return netlink_release_org(sock);
+}
+
+/** Receive message handler */
+static void _bcmtr_nl_recv(bcmolt_devid device, bcmos_buf *buf, bcmtrmux_channel channel, void *data)
+{
+ uint32_t data_length = bcmos_buf_length(buf);
+ uint32_t device_u32 = (uint32_t)device;
+ struct bcmtr_nl *nlb = (struct bcmtr_nl *)data;
+ uint8_t *p_device;
+ int r;
+
+ NETLINK_CB(&(buf->skb)).dst_group = 0; /* not in mcast group */
+
+ /* Now a tricky part. nlmsg_put() assumes that skb is empty and extends it
+ * by total msg size. We don't want it. Reserve room for nlmsg header and then
+ * set size to 0 and let nlmsg_put() restore it
+ */
+ if (unlikely(skb_headroom(&buf->skb) < NLMSG_HDRLEN + sizeof(uint32_t)))
+ {
+ printk(KERN_INFO "%s: can't prepend NL header\n", __FUNCTION__);
+ bcmos_free(buf);
+ return;
+ }
+ __skb_push(&buf->skb, NLMSG_HDRLEN + sizeof(uint32_t));
+ /* Store device immediately after the NL header */
+ p_device = buf->skb.data + NLMSG_HDRLEN;
+ memcpy(p_device, &device_u32, sizeof(uint32_t));
+ __skb_trim(&buf->skb, 0);
+ nlmsg_put(&buf->skb, 0, 0, NLMSG_DONE, data_length + sizeof(uint32_t), 0);
+
+ r = nlmsg_unicast(nlb->sk, &buf->skb, nlb->pid);
+ if (r)
+ {
+ printk(KERN_INFO "%s: nlmsg_unicast() --> %d len=%u rm_alloc=%d recvbuf=%d\n",
+ __FUNCTION__, r, data_length, atomic_read(&nlb->sk->sk_rmem_alloc), nlb->sk->sk_rcvbuf);
+ }
+}
+
+void bcmtr_nl_input(struct sk_buff *skb)
+{
+ struct nlmsghdr *nlh;
+ struct bcmtr_nl *nlb;
+ uint32_t device;
+ bcmos_errno rc;
+
+ nlh = nlmsg_hdr(skb);
+
+ if(NLMSG_OK(nlh, skb->len))
+ {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,10,0)
+ struct sock *sk = NETLINK_CB(skb).sk;
+#else
+ struct sock *sk = NETLINK_CB(skb).ssk;
+#endif
+
+ /* channel is stored in user_data. If it is 0 - that means that channel
+ * is not allocated yet. Do it here
+ */
+ if (!sk->sk_user_data)
+ {
+ nlb = kmalloc(sizeof(*nlb), GFP_KERNEL);
+ if (!nlb)
+ {
+ printk(KERN_INFO "%s: can't allocate NLB\n", __FUNCTION__);
+ return;
+ }
+ memset(nlb, 0, sizeof(*nlb));
+ nlb->pid = nlh->nlmsg_pid;
+ nlb->sk = sk;
+ sk->sk_user_data = nlb;
+
+ /* Override release callback in order to cleanup */
+ bcmtr_nl_ops = *sk->sk_socket->ops;
+ netlink_release_org = bcmtr_nl_ops.release;
+ bcmtr_nl_ops.release = bcmtr_netlink_release;
+ sk->sk_socket->ops = &bcmtr_nl_ops;
+
+ /* Override sk_rcvbuf size. Set min */
+ if (sk->sk_rcvbuf < BCMTR_MIN_RCVBUF_SIZE)
+ {
+ sk->sk_rcvbuf = BCMTR_MIN_RCVBUF_SIZE;
+ }
+ }
+ else
+ {
+ nlb = (struct bcmtr_nl *)sk->sk_user_data;
+ }
+
+ /* Device id follows NLMSG header */
+ device = skb->data[NLMSG_HDRLEN];
+ if (device >= BCMTR_MAX_OLTS)
+ {
+ printk(KERN_INFO "%s: device %u is insane\n", __FUNCTION__, device);
+ return;
+ }
+
+ if (!nlb->channel[device])
+ {
+ bcmtrmux_channel channel = BCMTRMUX_CHANNEL_AUTO_ASSIGN;
+
+ rc = bcmtrmux_channel_register(device, &channel, _bcmtr_nl_recv, nlb);
+ if (rc)
+ {
+ printk(KERN_INFO "%s: can't register channel for device %u. rc=%d\n", __FUNCTION__, device, (int)rc);
+ return;
+ }
+ nlb->channel[device] = channel;
+ }
+
+
+ /* Cut NL header + device */
+ skb_pull(skb, NLMSG_HDRLEN + sizeof(uint32_t));
+
+ /* Clone skb because caller will release the original one */
+ skb = skb_clone(skb, 0);
+ if (!skb)
+ {
+
+ printk(KERN_ERR "Failed to allocate new skb\n");
+ return;
+ }
+
+ /* Forward to the mux */
+ bcmtrmux_rx_from_host(device, nlb->channel[device], (bcmos_buf *)skb);
+ }
+ else
+ {
+ printk(KERN_INFO "%s: invalid message received frpm pid %d\n", __FUNCTION__, nlh->nlmsg_pid);
+ }
+}
+
+static struct netlink_kernel_cfg bcmtr_nl_cfg = {
+ .input = bcmtr_nl_input,
+};
+
+bcmos_errno bcmtr_nl_init(void)
+{
+ printk(KERN_INFO "Maple netlink-based raw driver transport driver\n");
+ bcmtr_nl_sock = netlink_kernel_create(&init_net, BCMTR_NL_FAMILY, &bcmtr_nl_cfg);
+ if(!bcmtr_nl_sock)
+ return BCM_ERR_NOMEM;
+ return BCM_ERR_OK;
+}
+
+void bcmtr_nl_exit(void)
+{
+ printk("Maple netlink-based raw driver terminated\n");
+ if (bcmtr_nl_sock)
+ {
+ netlink_kernel_release(bcmtr_nl_sock);
+ bcmtr_nl_sock = NULL;
+ }
+}
diff --git a/bcm68620_release/release/host_customized/transport/nl_socket/bcmolt_tr_nl_driver.h b/bcm68620_release/release/host_customized/transport/nl_socket/bcmolt_tr_nl_driver.h
new file mode 100644
index 0000000..d79c990
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/nl_socket/bcmolt_tr_nl_driver.h
@@ -0,0 +1,42 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmtr_nl_driver.h - host netlink-socket transport driver
+ */
+
+#ifndef BCMOLT_TR_NL_DRIVER_H_
+#define BCMOLT_TR_NL_DRIVER_H_
+
+#include <bcmos_system.h>
+
+bcmos_errno bcmtr_nl_init(void);
+void bcmtr_nl_exit(void);
+
+#endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/Makefile b/bcm68620_release/release/host_customized/transport/plugin/Makefile
new file mode 100644
index 0000000..80f0147
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/Makefile
@@ -0,0 +1,11 @@
+# Transport: Plugin interface
+#
+MOD_NAME = tr_plugin
+MOD_TYPE = lib
+MOD_DEPS = utils common_api model
+
+ifeq ("$(RELEASE_BUILD)", "y")
+MOD_INC_DIRS = $(SRC_DIR) $(TOP_DIR)/host_driver/transport
+else
+MOD_INC_DIRS = $(SRC_DIR) $(SRC_DIR)/..
+endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/bcmtr_plugin.h b/bcm68620_release/release/host_customized/transport/plugin/bcmtr_plugin.h
new file mode 100644
index 0000000..82d3dd2
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/bcmtr_plugin.h
@@ -0,0 +1,113 @@
+/*
+<: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 BCMTR_PLUGIN_H_
+#define BCMTR_PLUGIN_H_
+
+#include <bcmolt_buf.h>
+#include <bcmolt_msg.h>
+
+#include <bcmtr_interface.h>
+#include <bcmtr_header.h>
+
+/** Message transport type */
+typedef enum
+{
+ BCMTR_TYPE_UDP, /**< UDP transport */
+ BCMTR_TYPE_RAW /**< Raw transport */
+} bcmtr_transport_type;
+
+/** UDP configuration */
+typedef struct
+{
+ uint32_t my_ip; /**< Local IP address in host format */
+ uint32_t remote_ip; /**< Remote IP address in host format */
+ uint16_t my_port; /**< Local UDP port in host format. INADDR_ANY is acceptable */
+ uint16_t remote_port; /**< Remote UDP port in host format */
+} bcmtr_udp_cfg;
+
+/** Transport configuration parameters */
+typedef struct
+{
+ bcmtr_transport_type type; /**< Transport type */
+
+ /** Type-specific configuration */
+ union
+ {
+ /** UDP Plugin parameters */
+ bcmtr_udp_cfg udp;
+
+ /* Raw task forwarder plugin parameters */
+ struct
+ {
+ bcmtr_udp_cfg udp; /**< UDP configuration - for UDP-based raw driver */
+ uint32_t max_txq_size; /**< Max transmit queue/pool size */
+ bcmos_task_priority tx_pri; /**< Tx task priority */
+ } forwarder;
+ } x;
+
+ uint32_t headroom; /**< Additional headroom length that should be reserved for plugin use */
+
+} bcmtr_plugin_cfg;
+
+/** Plugin channel */
+typedef unsigned long bcmtr_plugin_channel;
+
+/** Transport driver */
+typedef struct {
+ /** Open communication channel, establish communication */
+ bcmos_errno (*open)(int device, bcmtr_plugin_cfg *cfg, bcmtr_plugin_channel *ch);
+ /** Close communication channel */
+ bcmos_errno (*close)(bcmtr_plugin_channel ch);
+ /** Send data. It doesn't have to release the tx buffer, but if it does - it must
+ * clear buf->start to prevent double release */
+ bcmos_errno (*send)(bcmtr_plugin_channel ch, bcmolt_subchannel subch, bcmolt_buf *buf, bcmtr_send_flags flags);
+ /** Receive data. It is responsible for receive buffer allocation */
+ bcmos_errno (*recv)(bcmtr_plugin_channel ch, bcmolt_subchannel *subch, bcmolt_buf *buf);
+} bcmtr_driver;
+
+/** Initialize plugin callbacks
+ * \param[in] cfg Plugin configuration
+ * \param[in,out] driver Transport plugin driver structure
+ * \return error code
+ */
+bcmos_errno bcmtr_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver);
+
+/* UDP comm parameters */
+#ifdef BCMTR_UDP_SUPPORT
+extern uint32_t bcmtr_host_ip;
+extern uint16_t bcmtr_host_udp_port;
+extern uint32_t bcmtr_olt_ip[BCMTR_MAX_OLTS];
+extern uint16_t bcmtr_olt_udp_port[BCMTR_MAX_OLTS];
+#endif
+
+void using_inband_set(bcmos_bool using_inband);
+bcmos_bool using_inband_get(void);
+
+#endif /* BCMTR_PLUGIN_H_ */
diff --git a/bcm68620_release/release/host_customized/transport/plugin/direct/bcmtr_plugin_direct.c b/bcm68620_release/release/host_customized/transport/plugin/direct/bcmtr_plugin_direct.c
new file mode 100644
index 0000000..c00c9ba
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/direct/bcmtr_plugin_direct.c
@@ -0,0 +1,290 @@
+/*
+<: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.
+:>
+*/
+/*
+ * bcmtr_plugin_direct.c
+ *
+ * This plugin
+ * - TX: forwards messages to trmux
+ * - RX: waits on rx task's message queue
+ */
+
+#include <bcmos_system.h>
+
+#include <bcmtr_plugin.h>
+#include <bcm_config.h>
+#include <bcmolt_tr_mux.h>
+
+/* Receive OS message pool and queue */
+static bcmos_msg_pool bcmtr_rx_msg_pool[BCMTR_MAX_OLTS];
+static bcmos_msg_queue bcmtr_rxq[BCMTR_MAX_OLTS];
+
+/* Flags indicating init progress */
+static bcmos_bool rx_pool_created[BCMTR_MAX_OLTS];
+static bcmos_bool rxq_created[BCMTR_MAX_OLTS];
+static void _bcmtr_direct_rx_from_trmux(bcmolt_devid device, bcmos_buf *buf, bcmtrmux_channel channel, void *data);
+
+/* To resolve symbols in user_appl in band not applicable for VXWorks*/
+void using_inband_set(bcmos_bool using_inband){}
+bcmos_bool using_inband_get(void)
+{
+ return BCMOS_FALSE;
+}
+
+
+/* Transport IPC message data */
+typedef struct bcmtr_ipc_data
+{
+ bcmolt_buf buf; /* Rx buffer */
+ bcmolt_subchannel subch; /* rx channel */
+} bcmtr_ipc_data;
+
+
+/* System --> OLT buffer translation.
+ * system buffer is released in case of success
+ */
+static bcmos_errno bcmtr_sysbuf_to_oltbuf(bcmos_buf *sysb, bcmolt_buf *oltb)
+{
+ bcmos_errno err;
+
+ err = bcmolt_buf_alloc(oltb, bcmos_buf_length(sysb), BCMTR_BUF_ENDIAN);
+ if (err)
+ return err;
+ bcmolt_buf_write(oltb, bcmos_buf_data(sysb), bcmos_buf_length(sysb));
+ bcmos_buf_free(sysb);
+ oltb->curr = oltb->start;
+ return BCM_ERR_OK;
+}
+
+/* OLT buffer --> system buffer translation.
+ * OLT buffer must have headroom for bcmos_buf header
+ */
+static bcmos_buf *bcmtr_oltbuf_to_sysbuf(bcmolt_buf *oltb)
+{
+ bcmos_buf *sysb;
+ uint32_t len = bcmolt_buf_get_used(oltb);
+
+ sysb = bcmos_buf_alloc(len);
+ if (sysb == NULL)
+ return NULL;
+ memcpy(bcmos_buf_data(sysb), oltb->start, len);
+ bcmos_buf_length_set(sysb, len);
+ /* We don't release the original oltb because it is needed for retransmission.
+ * It will be released by the transport layer
+ */
+ return sysb;
+}
+
+/* Release message data */
+static void bcmtr_msg_data_release(bcmos_msg *msg)
+{
+ bcmtr_ipc_data *data = msg->data;
+ bcmolt_buf_free(&data->buf);
+}
+
+/** Close communication channel */
+static bcmos_errno bcmtr_direct_close(bcmtr_plugin_channel ch)
+{
+ bcmolt_devid device = (bcmolt_devid)(ch >> 8);
+ bcmtrmux_channel muxch = (bcmtrmux_channel)(ch & 0xff);
+
+ /* Unregister from TRMUX */
+ bcmtrmux_channel_unregister(device, muxch);
+
+ /* Destroy rx message pool */
+ if (rx_pool_created[device])
+ {
+ bcmos_msg_pool_destroy(&bcmtr_rx_msg_pool[device]);
+ rx_pool_created[device] = BCMOS_FALSE;
+ }
+
+ /* Destroy RX message queue */
+ if (rxq_created[device])
+ {
+ bcmos_msg_queue_destroy(&bcmtr_rxq[device]);
+ rxq_created[device] = BCMOS_FALSE;
+ }
+
+ return BCM_ERR_OK;
+}
+
+/** Open communication channel */
+static bcmos_errno bcmtr_direct_open(int device, bcmtr_plugin_cfg *cfg, bcmtr_plugin_channel *ch)
+{
+ /* The following variables are declared static in order to protect name string */
+ static bcmos_msg_queue_parm msgq_parm = { .name = "tr_rxq"};
+ bcmos_msg_pool_parm msg_pool_parm = {};
+ bcmtrmux_channel mux_channel = BCMTRMUX_CHANNEL_AUTO_ASSIGN;
+ bcmos_errno err;
+
+ /* Direct plugin supports only 1 application instance */
+ if (device >= BCMTR_MAX_OLTS)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Device %u is out of range\n", device);
+ if (rx_pool_created[device])
+ BCMOS_TRACE_RETURN(BCM_ERR_ALREADY, "Transport is already initialized for device %u\n", device);
+
+ /* Create RX msg pool */
+ msg_pool_parm.size = BCMTR_MAX_RXQ_SIZE; /* <-- Define parameter in bcmtr_config */
+ msg_pool_parm.data_size = sizeof(bcmtr_ipc_data);
+ msg_pool_parm.data_release = bcmtr_msg_data_release;
+ err = bcmos_msg_pool_create(&bcmtr_rx_msg_pool[device], &msg_pool_parm);
+ if (err)
+ BCMOS_TRACE_RETURN(err, "Can't create rx pool\n");
+
+ /* Create RX queue set */
+ err = bcmos_msg_queue_create(&bcmtr_rxq[device], &msgq_parm);
+ if (err)
+ {
+ bcmos_msg_pool_destroy(&bcmtr_rx_msg_pool[device]);
+ BCMOS_TRACE_RETURN(err, "Can't create rxq\n");
+ }
+
+ /* Register with trmux */
+ err = bcmtrmux_channel_register(device, &mux_channel, _bcmtr_direct_rx_from_trmux, (void *)NULL );
+ if (err)
+ {
+ bcmos_msg_pool_destroy(&bcmtr_rx_msg_pool[device]);
+ bcmos_msg_queue_destroy(&bcmtr_rxq[device]);
+ BCMOS_TRACE_RETURN(err, "Can't register with trmux\n");
+ }
+
+ rx_pool_created[device] = BCMOS_TRUE;
+ rxq_created[device] = BCMOS_TRUE;
+ *ch = (bcmtr_plugin_channel)((device << 8) | mux_channel);
+
+ return BCM_ERR_OK;
+}
+
+/** Send data */
+static bcmos_errno bcmtr_direct_send(bcmtr_plugin_channel ch, bcmolt_subchannel subch, bcmolt_buf *buf,
+ bcmtr_send_flags flags)
+{
+ bcmolt_devid device = (bcmolt_devid)(ch >> 8);
+ bcmtrmux_channel muxch = (bcmtrmux_channel)(ch & 0xff);
+ bcmos_buf *sysb;
+
+ /* Do zero-copy conversion from bcmolt_buf --> bcmos_buf. It is possible because room
+ * for bcmos_buf header is reserved in the beginning of bcmolt_buf
+ */
+ sysb = bcmtr_oltbuf_to_sysbuf(buf);
+ if (!sysb)
+ return BCM_ERR_NOMEM;
+ bcmtrmux_rx_from_host(device, muxch, sysb);
+
+ return BCM_ERR_OK;
+}
+
+/* Receive from trmux. Called in trmux context */
+static void _bcmtr_direct_rx_from_trmux(bcmolt_devid device, bcmos_buf *sysb, bcmtrmux_channel channel, void *data)
+{
+ bcmos_msg *msg;
+ bcmtr_ipc_data *ipc_data;
+ bcmos_errno err;
+
+ msg = bcmos_msg_pool_alloc(&bcmtr_rx_msg_pool[device]);
+ if (!msg)
+ {
+ /* <-- add some statistic here */
+ bcmos_buf_free(sysb);
+ return;
+ }
+ ipc_data = msg->data;
+ err = bcmtr_sysbuf_to_oltbuf(sysb, &ipc_data->buf);
+ if (err)
+ {
+ /* <-- add some statistic here */
+ bcmos_buf_free(sysb);
+ bcmos_msg_free(msg);
+ return;
+ }
+ ipc_data->subch = channel;
+ err = bcmos_msg_send(&bcmtr_rxq[device], msg, BCMOS_MSG_SEND_AUTO_FREE);
+ if (err)
+ {
+ /* <-- add some statistic here */
+ }
+}
+
+/** Receive data */
+static bcmos_errno bcmtr_direct_recv(bcmtr_plugin_channel ch, bcmolt_subchannel *subch, bcmolt_buf *buf)
+{
+ bcmolt_devid device = (bcmolt_devid)(ch >> 8);
+ bcmos_msg *msg;
+ bcmtr_ipc_data *data;
+ bcmos_errno err;
+
+ err = bcmos_msg_recv(&bcmtr_rxq[device], BCMTR_MSG_TIMEOUT, &msg);
+ if (err)
+ {
+ if (err != BCM_ERR_TIMEOUT)
+ err = BCM_ERR_COMM_FAIL;
+ return err;
+ }
+
+ data = msg->data;
+ *buf = data->buf;
+ *subch = data->subch;
+ /* Prevent buffer release when releasing OS message */
+ data->buf.start = data->buf.curr = NULL;
+ bcmos_msg_free(msg);
+
+ return BCM_ERR_OK;
+}
+
+/** Initialize plugin callbacks
+ * \param[in,out] driver Transport plugin driver structure
+ * \return error code
+ */
+bcmos_errno bcmtr_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver)
+{
+ driver->open = bcmtr_direct_open;
+ driver->close = bcmtr_direct_close;
+ driver->recv = bcmtr_direct_recv;
+ driver->send = bcmtr_direct_send;
+
+ return BCM_ERR_OK;
+}
+
diff --git a/bcm68620_release/release/host_customized/transport/plugin/mux/Makefile b/bcm68620_release/release/host_customized/transport/plugin/mux/Makefile
new file mode 100755
index 0000000..acf736a
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/mux/Makefile
@@ -0,0 +1,16 @@
+#
+# transport plugin
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+ifeq ("$(CONFIG_TRANSPORT_RAW)", "y")
+MOD_NAME = tr_plugin_mux
+MOD_TYPE = lib
+MOD_DEPS = tr_plugin_raw tr_plugin_raw_ud
+
+MOD_DEFS = -DBCMTR_PLUGIN_RAW
+
+srcs = bcmtr_nl_ud_mux.c
+
+endif
+endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/mux/bcmtr_nl_ud_mux.c b/bcm68620_release/release/host_customized/transport/plugin/mux/bcmtr_nl_ud_mux.c
new file mode 100755
index 0000000..cabaf47
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/mux/bcmtr_nl_ud_mux.c
@@ -0,0 +1,40 @@
+
+#include <bcmos_system.h>
+#include <bcmtr_plugin.h>
+#include "bcmolt_tr_ud.h"
+#include "bcmolt_tr_nl.h"
+#include "bcmtr_internal.h"
+
+static bcmos_bool use_inband = BCMOS_FALSE;
+void using_inband_set(bcmos_bool using_inband)
+{
+ use_inband = using_inband;
+}
+bcmos_bool using_inband_get(void)
+{
+ return use_inband;
+}
+
+
+/** Initialize plugin callbacks
+ * \param[in,out] driver Transport plugin driver structure
+ * \return error code
+ */
+bcmos_errno bcmtr_plugin_init(bcmtr_plugin_cfg *plugin_cfg, bcmtr_driver *driver)
+{
+ bcmos_errno rc = BCM_ERR_NOT_SUPPORTED;
+
+#ifdef SIMULATION_BUILD
+ rc = bcmtr_plugin_init(plugin_cfg, driver);
+#else
+ if (using_inband_get())
+ {
+ rc = bcmtr_ud_plugin_init(plugin_cfg, driver);
+ } else
+ {
+ rc = bcmtr_nl_plugin_init(plugin_cfg, driver);
+ }
+#endif
+
+ return rc;
+}
diff --git a/bcm68620_release/release/host_customized/transport/plugin/raw_nl/Makefile b/bcm68620_release/release/host_customized/transport/plugin/raw_nl/Makefile
new file mode 100644
index 0000000..8947722
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/raw_nl/Makefile
@@ -0,0 +1,15 @@
+#
+# NL transport plugin
+#
+ifeq ("$(OS_KERNEL)", "linux")
+ifeq ("$(CONFIG_TRANSPORT_RAW)", "y")
+
+MOD_NAME = tr_plugin_raw
+MOD_TYPE = lib
+MOD_DEPS = tr_plugin
+MOD_DEFS = -DBCMTR_PLUGIN_RAW
+
+srcs = bcmolt_tr_plugin_nl_socket.c
+
+endif
+endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/raw_nl/bcmolt_tr_nl.h b/bcm68620_release/release/host_customized/transport/plugin/raw_nl/bcmolt_tr_nl.h
new file mode 100644
index 0000000..0707c3c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/raw_nl/bcmolt_tr_nl.h
@@ -0,0 +1,40 @@
+/*
+<: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_TR_NL_H_
+#define BCMOLT_TR_NL_H_
+
+#include "bcmtr_internal.h"
+
+/* NL family. Must be some unused number */
+#define BCMTR_NL_FAMILY 28
+
+bcmos_errno bcmtr_nl_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver);
+
+#endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/raw_nl/bcmolt_tr_plugin_nl_socket.c b/bcm68620_release/release/host_customized/transport/plugin/raw_nl/bcmolt_tr_plugin_nl_socket.c
new file mode 100644
index 0000000..df45234
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/raw_nl/bcmolt_tr_plugin_nl_socket.c
@@ -0,0 +1,339 @@
+/*
+<: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 <sys/types.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <poll.h>
+
+#include <bcmos_system.h>
+#include <bcmtr_plugin.h>
+#include <bcm_config.h>
+#include <bcmolt_tr_nl.h>
+
+#define BCMNL_TXPREFIX_LEN (NLMSG_HDRLEN + sizeof(uint32_t))
+
+
+/* Buffer list header */
+typedef struct bcmtr_nl_buf bcmtr_nl_buf;
+struct bcmtr_nl_buf
+{
+ STAILQ_ENTRY(bcmtr_nl_buf) list;
+ uint32_t len; /**< Total Length of buffer */
+};
+
+/* Plugin channel structure */
+typedef struct bcmtr_nl_channel
+{
+ int device; /* Device */
+ STAILQ_HEAD(nl_buf_list, bcmtr_nl_buf) buf_list;
+ bcmos_sem sem; /* Semaphore that indicates that new buffer is available */
+ bcmos_mutex lock; /* lock that protects this structure */
+} bcmtr_nl_channel;
+
+/* A single NL socket is shared by multiple devices.
+ * The following control block is used for socket multiplexing
+ */
+static struct
+{
+ int s; /* Netlink socket */
+ int users; /* Number of users */
+ bcmos_mutex lock; /* lock that protects this structure */
+ bcmos_task nl_rx_task; /* Task that reads from the shared NL socket */
+ bcmtr_nl_channel *nlch[BCMTR_MAX_OLTS]; /* Channels */
+} bcmtr_nl_common;
+
+/* NL socket RX task handler */
+static int bcmtr_nl_rx_task_handler(long data);
+
+/** Open first communication channel */
+static bcmos_errno bcmtr_nl_open_first(void)
+{
+ struct sockaddr_nl sa = {};
+ bcmos_task_parm tp = {
+ .name = "nl_tx",
+ .handler = bcmtr_nl_rx_task_handler,
+ .priority = TASK_PRIORITY_TRANSPORT_RX
+ };
+ int s;
+ bcmos_errno err;
+
+ s = socket(AF_NETLINK, SOCK_RAW, BCMTR_NL_FAMILY);
+ if (s < 0)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't create NL socket\n");
+ }
+
+ /* Connect to remote */
+ sa.nl_pid = 0;
+ if (connect(s, (struct sockaddr*)&sa, sizeof(sa)) == -1)
+ {
+ close(s);
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't connect NL socket. error %d (%s)\n",
+ errno, strerror(errno));
+ }
+
+ /* Bind local */
+ sa.nl_family = AF_NETLINK;
+ sa.nl_pid = getpid();
+ if (bind(s, (struct sockaddr*)&sa, sizeof(sa) ) == -1)
+ {
+ close(s);
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't bind NL socket. error %d (%s)\n",
+ errno, strerror(errno));
+ }
+
+ bcmtr_nl_common.s = s;
+
+ /* Create RX thread */
+ err = bcmos_task_create(&bcmtr_nl_common.nl_rx_task, &tp);
+ if (err)
+ {
+ close(s);
+ bcmtr_nl_common.s = 0;
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't create NL RX thread. error %d (%s)\n",
+ err, bcmos_strerror(err));
+ }
+
+ return BCM_ERR_OK;
+}
+
+/** Close last communication channel */
+static bcmos_errno bcmtr_nl_close_last(void)
+{
+ close(bcmtr_nl_common.s);
+ return bcmos_task_destroy(&bcmtr_nl_common.nl_rx_task);
+}
+
+/** Open communication channel */
+static bcmos_errno bcmtr_nl_open(int device, bcmtr_plugin_cfg *cfg, bcmtr_plugin_channel *ch)
+{
+ bcmtr_nl_channel *nlch;
+ bcmos_errno err = BCM_ERR_OK;
+
+ if ((unsigned)device >= BCMTR_MAX_OLTS)
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Device %d is invalid\n");
+
+ if (bcmtr_nl_common.nlch[device])
+ BCMOS_TRACE_RETURN(BCM_ERR_ALREADY, "Channel for device %d is already opened\n");
+
+ nlch = bcmos_calloc(sizeof(*nlch));
+ if (!nlch)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "No memory\n");
+ }
+ nlch->device = device;
+ STAILQ_INIT(&nlch->buf_list);
+ err = bcmos_mutex_create(&nlch->lock, 0, "tr_nlch");
+ err = err ? err : bcmos_sem_create(&nlch->sem, 0, 0, "tr_nlch");
+
+ /* Tie in with the control block shared by all devices */
+ bcmos_mutex_lock(&bcmtr_nl_common.lock);
+ if (!bcmtr_nl_common.users)
+ err = err ? err : bcmtr_nl_open_first();
+ if (err)
+ {
+ bcmos_mutex_unlock(&bcmtr_nl_common.lock);
+ bcmos_free(nlch);
+ BCMOS_TRACE_RETURN(err, "Failed to open or bind NL socket\n");
+ }
+ ++bcmtr_nl_common.users;
+ bcmtr_nl_common.nlch[device] = nlch;
+ bcmos_mutex_unlock(&bcmtr_nl_common.lock);
+
+ *ch = (bcmtr_plugin_channel)nlch;
+
+ return BCM_ERR_OK;
+}
+
+/** Close communication channel */
+static bcmos_errno bcmtr_nl_close(bcmtr_plugin_channel ch)
+{
+ bcmtr_nl_channel *nlch = (bcmtr_nl_channel *)ch;
+ bcmtr_nl_buf *nl_buf, *nl_buf_tmp;
+ bcmolt_buf buf;
+ bcmos_errno err = BCM_ERR_OK;
+
+ bcmos_mutex_lock(&bcmtr_nl_common.lock);
+ if (bcmtr_nl_common.nlch[nlch->device] == nlch)
+ {
+ bcmtr_nl_common.nlch[nlch->device] = NULL;
+ --bcmtr_nl_common.users;
+ if (bcmtr_nl_common.users)
+ err = bcmtr_nl_close_last();
+ }
+ else
+ {
+ BCMOS_TRACE_ERR("Unexpected NL channel\n");
+ err = BCM_ERR_INTERNAL;
+ }
+ bcmos_mutex_unlock(&bcmtr_nl_common.lock);
+ bcmos_mutex_destroy(&nlch->lock);
+ bcmos_sem_destroy(&nlch->sem);
+ STAILQ_FOREACH_SAFE(nl_buf, &nlch->buf_list, list, nl_buf_tmp)
+ {
+ STAILQ_REMOVE_HEAD(&nlch->buf_list, list);
+ bcmolt_buf_init(&buf, nl_buf->len, (uint8_t *)nl_buf, BCMTR_BUF_ENDIAN);
+ bcmolt_buf_free(&buf);
+ }
+ bcmos_free(nlch);
+
+ return err;
+}
+
+/** Send data */
+static bcmos_errno bcmtr_nl_send(bcmtr_plugin_channel ch, bcmolt_subchannel subch, bcmolt_buf *buf,
+ bcmtr_send_flags flags)
+{
+ bcmtr_nl_channel *nlch = (bcmtr_nl_channel *)ch;
+ int total_len = bcmolt_buf_get_used(buf);
+ struct nlmsghdr *nlmsg_hdr = (struct nlmsghdr *)(long)buf->start;
+ struct iovec iov = { buf->start, .iov_len=total_len };
+ struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1 };
+ int rc;
+
+ nlmsg_hdr->nlmsg_len = total_len;
+ nlmsg_hdr->nlmsg_pid = getpid();
+ buf->start[NLMSG_HDRLEN] = nlch->device;
+
+ rc = sendmsg(bcmtr_nl_common.s, &msg, 0);
+
+ return (rc == total_len) ? BCM_ERR_OK : BCM_ERR_COMM_FAIL;
+}
+
+/* NL socket RX task handler */
+static int bcmtr_nl_rx_task_handler(long data)
+{
+ bcmos_task *my_task = bcmos_task_current();
+ struct iovec iov;
+ struct msghdr msg = { .msg_iov = &iov, .msg_iovlen = 1 };
+ uint32_t device;
+ bcmolt_buf buf = {};
+ bcmtr_nl_buf *nl_buf;
+ bcmtr_nl_channel *nlch;
+ bcmos_errno err;
+ int rc;
+
+ while (!my_task->destroy_request)
+ {
+ err = bcmolt_buf_alloc(&buf, BCMTR_MAX_MTU_SIZE + BCMNL_TXPREFIX_LEN, BCMTR_BUF_ENDIAN);
+ if (err)
+ {
+ /* We are out of memory, hopefully temporary. Wait and continue */
+ bcmos_usleep(1000);
+ continue;
+ }
+ iov.iov_base = buf.start;
+ iov.iov_len = buf.len;
+
+ /* Wait for message */
+ rc = recvmsg(bcmtr_nl_common.s, &msg, 0);
+ if (rc < NLMSG_HDRLEN)
+ {
+ BCMOS_TRACE_ERR("Fatal error. recvmsg() failed with error %d (%s)\n", errno, strerror(errno));
+ break;
+ }
+
+ /* Device follows NL header */
+ memcpy(&device, buf.start + NLMSG_HDRLEN, sizeof(uint32_t));
+ if (device >= BCMTR_MAX_OLTS || !(nlch = bcmtr_nl_common.nlch[device]))
+ {
+ BCMOS_TRACE_ERR("Got message from unexpected device %u. Ignored\n", device);
+ bcmolt_buf_free(&buf);
+ continue;
+ }
+
+ /* Put message on the channel's queue */
+ nl_buf = (bcmtr_nl_buf *)(long)buf.start;
+ nl_buf->len = rc;
+ bcmos_mutex_lock(&nlch->lock);
+ STAILQ_INSERT_TAIL(&nlch->buf_list, nl_buf, list);
+ bcmos_mutex_unlock(&nlch->lock);
+ bcmos_sem_post(&nlch->sem);
+
+ /* Buffer is in use elsewhere */
+ buf.start = buf.curr = NULL;
+ }
+
+ bcmolt_buf_free(&buf);
+ my_task->destroyed = BCMOS_TRUE;
+ return 0;
+}
+
+/** Receive data */
+static bcmos_errno bcmtr_nl_recv(bcmtr_plugin_channel ch, bcmolt_subchannel *subch, bcmolt_buf *buf)
+{
+ bcmtr_nl_channel *nlch = (bcmtr_nl_channel *)ch;
+ bcmtr_nl_buf *nl_buf;
+ bcmos_errno err;
+
+ err = bcmos_sem_wait(&nlch->sem, BCMTR_MSG_TIMEOUT * 1000);
+ if (err)
+ return err;
+ bcmos_mutex_lock(&nlch->lock);
+ nl_buf = STAILQ_FIRST(&nlch->buf_list);
+ if (!nl_buf)
+ {
+ bcmos_mutex_unlock(&nlch->lock);
+ return BCM_ERR_COMM_FAIL;
+ }
+ STAILQ_REMOVE_HEAD(&nlch->buf_list, list);
+ bcmos_mutex_unlock(&nlch->lock);
+
+ /* Got buffer */
+ bcmolt_buf_init(buf, nl_buf->len, (uint8_t *)nl_buf, BCMTR_BUF_ENDIAN);
+ buf->curr = buf->start + BCMNL_TXPREFIX_LEN;
+
+ *subch = 0;
+
+ return BCM_ERR_OK;
+}
+
+/** Initialize plugin callbacks
+ * \param[in,out] driver Transport plugin driver structure
+ * \return error code
+ */
+bcmos_errno bcmtr_nl_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver)
+{
+ bcmos_errno err;
+
+ bcmos_printf("Launching with a netlink connection\n");
+
+ driver->open = bcmtr_nl_open;
+ driver->close = bcmtr_nl_close;
+ driver->recv = bcmtr_nl_recv;
+ driver->send = bcmtr_nl_send;
+ cfg->headroom = BCMNL_TXPREFIX_LEN;
+
+ err = bcmos_mutex_create(&bcmtr_nl_common.lock, 0, "tr_nl");
+
+ return err;
+}
+
diff --git a/bcm68620_release/release/host_customized/transport/plugin/raw_ud/Makefile b/bcm68620_release/release/host_customized/transport/plugin/raw_ud/Makefile
new file mode 100755
index 0000000..4126ef3
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/raw_ud/Makefile
@@ -0,0 +1,14 @@
+#
+# Unix Domain transport plugin
+#
+ifeq ("$(OS_KERNEL)", "linux")
+ifeq ("$(CONFIG_TRANSPORT_RAW)", "y")
+
+MOD_NAME = tr_plugin_raw_ud
+MOD_TYPE = lib
+MOD_DEPS = tr_plugin
+
+srcs = bcmolt_tr_plugin_ud_socket.c
+
+endif
+endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/raw_ud/bcmolt_tr_plugin_ud_socket.c b/bcm68620_release/release/host_customized/transport/plugin/raw_ud/bcmolt_tr_plugin_ud_socket.c
new file mode 100755
index 0000000..14d9003
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/raw_ud/bcmolt_tr_plugin_ud_socket.c
@@ -0,0 +1,182 @@
+/*
+<: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 <sys/socket.h>
+#include <sys/un.h>
+
+#include <bcmos_system.h>
+#include <bcmtr_plugin.h>
+#include <bcm_config.h>
+#include <bcmolt_tr_ud.h>
+
+char socket_path[] = SOCKET_PATH;
+/* Plugin channel structure */
+typedef struct bcmtr_ud_channel
+{
+ int device; /* Device */
+ int sock; /* UD socket */
+} bcmtr_ud_channel;
+
+
+/* This plugin stores both device id and per-device socket handle in
+ * transport's channel_id handle as
+ * (device_id << 24) | socket_handle.
+ * The following functions recover socket_handle and device_id from the channel_id handle
+ */
+
+
+/** Open communication channel */
+static bcmos_errno bcmtr_ud_open(int device, bcmtr_plugin_cfg *cfg, bcmtr_plugin_channel *ch)
+{
+ struct sockaddr_un addr;
+ bcmtr_ud_channel *udch;
+
+ udch = bcmos_calloc(sizeof(*udch));
+ if (!udch)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "No memory\n");
+ }
+
+ if ( (udch->sock = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ perror("socket error");
+ exit(-1);
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ BUG_ON(sizeof(socket_path)>=sizeof(addr.sun_path));
+ memcpy(addr.sun_path, socket_path, sizeof(socket_path));
+
+ if (connect(udch->sock, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+ perror("connect error");
+ exit(-1);
+ }
+
+ bcmos_printf("Opened %d\n", udch->sock);
+
+ udch->device = device;
+
+ *ch = (bcmtr_plugin_channel)udch;
+
+ return BCM_ERR_OK;
+}
+
+/** Close communication channel */
+static bcmos_errno bcmtr_ud_close(bcmtr_plugin_channel ch)
+{
+ bcmtr_ud_channel *udch = (bcmtr_ud_channel *)ch;
+
+ bcmos_printf("Closed %d\n", udch->sock);
+ close(udch->sock);
+ bcmos_free(udch);
+
+ return BCM_ERR_OK;
+}
+
+/** Send data */
+static bcmos_errno bcmtr_ud_send(bcmtr_plugin_channel ch, bcmolt_subchannel subch, bcmolt_buf *buf,
+ bcmtr_send_flags flags)
+{
+ bcmtr_ud_channel *udch = (bcmtr_ud_channel *)ch;
+ int buflen = bcmolt_buf_get_used(buf);
+ int len;
+ len = send(udch->sock, buf->start, buflen, 0);
+
+ if (len < buflen)
+ {
+ bcmos_printf("%s: sock_sendmsg(%u) --> %d. errno=%d\n", __FUNCTION__, buflen, len, errno);
+ return BCM_ERR_COMM_FAIL;
+ }
+
+ return BCM_ERR_OK;
+}
+
+/** Receive data */
+static bcmos_errno bcmtr_ud_recv(bcmtr_plugin_channel ch, bcmolt_subchannel *subch, bcmolt_buf *buf)
+{
+ bcmtr_ud_channel *udch = (bcmtr_ud_channel *)ch;
+ int len;
+ fd_set read_fds;
+ struct timeval tv;
+ bcmos_errno err;
+ int rc;
+
+ FD_ZERO(&read_fds);
+ FD_SET(udch->sock, &read_fds);
+ tv.tv_sec = 0;
+ tv.tv_usec = BCMTR_MSG_TIMEOUT * 1000;
+
+ rc = select(udch->sock + 1, &read_fds, NULL, NULL, &tv);
+ if (rc < 0)
+ {
+ perror("select");
+ return BCM_ERR_COMM_FAIL;
+ }
+ if (!rc || !FD_ISSET(udch->sock, &read_fds))
+ {
+ return BCM_ERR_TIMEOUT;
+ }
+
+ err = bcmolt_buf_alloc(buf, BCMTR_MAX_MTU_SIZE, BCMOLT_BUF_ENDIAN_FIXED);
+ if (err)
+ return BCM_ERR_NOMEM;
+
+ len = recv(udch->sock, buf->start, BCMTR_MAX_MTU_SIZE, 0);
+ if (len <= 0)
+ {
+ bcmolt_buf_free(buf);
+ return BCM_ERR_COMM_FAIL;
+ }
+
+ bcmos_printf("Received %d bytes from dev_control\n", len);
+
+ buf->len = len;
+ return BCM_ERR_OK;
+}
+
+/** Initialize plugin callbacks
+ * \param[in,out] driver Transport plugin driver structure
+ * \return error code
+ */
+bcmos_errno bcmtr_ud_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver)
+{
+ bcmos_errno err = BCM_ERR_OK;
+
+ bcmos_printf("Launching with a unix domain connection\n");
+
+ driver->open = bcmtr_ud_open;
+ driver->close = bcmtr_ud_close;
+ driver->recv = bcmtr_ud_recv;
+ driver->send = bcmtr_ud_send;
+ cfg->headroom = BCMUD_TXPREFIX_LEN;
+
+ return err;
+}
+
diff --git a/bcm68620_release/release/host_customized/transport/plugin/raw_ud/bcmolt_tr_ud.h b/bcm68620_release/release/host_customized/transport/plugin/raw_ud/bcmolt_tr_ud.h
new file mode 100755
index 0000000..bca32d4
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/raw_ud/bcmolt_tr_ud.h
@@ -0,0 +1,41 @@
+/*
+<: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_TR_UD_H_
+#define BCMOLT_TR_UD_H_
+
+#include "bcmtr_internal.h"
+
+#define BCMUD_TXPREFIX_LEN (sizeof(uint32_t))
+
+#define SOCKET_PATH "\0bcm68620"
+
+bcmos_errno bcmtr_ud_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver);
+
+#endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/udp/Makefile b/bcm68620_release/release/host_customized/transport/plugin/udp/Makefile
new file mode 100644
index 0000000..8106edc
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/udp/Makefile
@@ -0,0 +1,17 @@
+# Transport: UDP Plugin
+#
+
+CONFIG_TRANSPORT_RAW ?= n
+CONFIG_TRANSPORT_UDP ?= y
+ifeq ("$(CONFIG_TRANSPORT_RAW)", "y")
+ CONFIG_TRANSPORT_UDP = n
+endif
+
+ifeq ("$(CONFIG_TRANSPORT_UDP)", "y")
+MOD_NAME = tr_plugin_udp
+MOD_TYPE = lib
+MOD_DEPS = tr_plugin
+MOD_DEFS = -DBCMTR_UDP_SUPPORT
+
+srcs = bcmtr_plugin_udp_socket.c
+endif
diff --git a/bcm68620_release/release/host_customized/transport/plugin/udp/bcmtr_plugin_udp_socket.c b/bcm68620_release/release/host_customized/transport/plugin/udp/bcmtr_plugin_udp_socket.c
new file mode 100644
index 0000000..4ab4444
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/plugin/udp/bcmtr_plugin_udp_socket.c
@@ -0,0 +1,220 @@
+/*
+<: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 <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+
+#include <bcmtr_plugin.h>
+#include <bcm_config.h>
+
+/* Last seen host IP and port */
+static struct sockaddr_in peer_sa[BCMTR_MAX_OLTS];
+
+/* This plugin stores both device id and per-device socket handle in
+ * transport's channel_id handle as
+ * (device_id << 24) | socket_handle.
+ * The following functions recover socket_handle and device_id from the channel_id handle
+ */
+
+static inline int _bcmtr_channel_to_socket(bcmtr_plugin_channel ch)
+{
+ return (int)(ch & 0xffffff);
+}
+
+static inline int _bcmtr_channel_to_device(bcmtr_plugin_channel ch)
+{
+ return (int)((ch >> 24) & 0xff);
+}
+
+/** Open communication channel */
+static bcmos_errno bcmtr_udp_open(int device, bcmtr_plugin_cfg *cfg, bcmtr_plugin_channel *ch)
+{
+ struct sockaddr_in sa = {};
+ struct timeval timeout = { .tv_sec = 0, .tv_usec = BCMTR_MSG_TIMEOUT * 1000 };
+ int s;
+
+ s = socket(AF_INET, SOCK_DGRAM, 0);
+ if (s < 0)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't create UDP socket\n");
+ }
+
+ /* Bind local */
+ sa.sin_family = AF_INET;
+ sa.sin_port = htons(cfg->x.udp.my_port);
+ sa.sin_addr.s_addr = INADDR_ANY;
+ if (bind(s, (struct sockaddr*)&sa, sizeof(sa) ) == -1)
+ {
+ close(s);
+ perror("bind");
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't bind UDP socket to %d.%d.%d.%d:%d\n",
+ (int)(cfg->x.udp.my_ip >> 24), (int)((cfg->x.udp.my_ip >> 16) & 0xff),
+ (int)((cfg->x.udp.my_ip >> 8) & 0xff), (int)(cfg->x.udp.my_ip & 0xff),
+ (int)cfg->x.udp.my_port);
+ }
+ bcmos_printf("%s: socket bound to port %d\n", __FUNCTION__, (int)cfg->x.udp.my_port);
+
+ if (setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(timeout)) < 0)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_COMM_FAIL, "Can't set socket option for send timeout\n");
+ }
+
+ /* Connect to remote */
+ if (cfg->x.udp.remote_port)
+ {
+ peer_sa[device].sin_family = AF_INET;
+ peer_sa[device].sin_port = htons(cfg->x.udp.remote_port);
+ peer_sa[device].sin_addr.s_addr = htonl(cfg->x.udp.remote_ip);
+ }
+ *ch = (device << 24) | s;
+
+ return BCM_ERR_OK;
+}
+
+/* print error message with throttling: not oftener than ones per second */
+static void _bcmtr_udp_print_err(bcmos_errno err, const char *err_msg)
+{
+ static int nerrors;
+ static uint32_t last_timestamp;
+
+ ++nerrors;
+
+ if (!last_timestamp || bcmos_timestamp() - last_timestamp > 1000000)
+ {
+ BCMOS_TRACE_ERR("Error in low-level UDP transport. %s-%s. Errors since last report: %d\n",
+ err_msg, bcmos_strerror(err), nerrors);
+ last_timestamp = bcmos_timestamp();
+ nerrors = 0;
+ }
+}
+
+/** Close communication channel */
+static bcmos_errno bcmtr_udp_close(bcmtr_plugin_channel ch)
+{
+ close(_bcmtr_channel_to_socket(ch));
+ return BCM_ERR_OK;
+}
+
+/** Send data */
+static bcmos_errno bcmtr_udp_send(bcmtr_plugin_channel ch, bcmolt_subchannel subch, bcmolt_buf *buf,
+ bcmtr_send_flags flags)
+{
+ int sock = _bcmtr_channel_to_socket(ch);
+ int device = _bcmtr_channel_to_device(ch);
+ int buflen = bcmolt_buf_get_used(buf);
+ struct iovec iov = { .iov_base = buf->start, .iov_len = buflen };
+ struct msghdr msg = {
+ .msg_iov = &iov, .msg_iovlen = 1, .msg_flags = 0,
+ .msg_name = (void *)&peer_sa[device], .msg_namelen = sizeof(peer_sa[0])
+ };
+ int len;
+
+ len = sendmsg(sock, &msg, 0);
+ if (len < buflen)
+ {
+ bcmos_printf("%s: sock_sendmsg(%u) --> %d. errno=%d\n", __FUNCTION__, buflen, len, errno);
+ return BCM_ERR_COMM_FAIL;
+ }
+
+ return BCM_ERR_OK;
+}
+
+/** Receive data */
+static bcmos_errno bcmtr_udp_recv(bcmtr_plugin_channel ch, bcmolt_subchannel *subch, bcmolt_buf *buf)
+{
+ int sock = _bcmtr_channel_to_socket(ch);
+ int device = _bcmtr_channel_to_device(ch);
+ struct iovec iov;
+ struct msghdr msg = {
+ .msg_iov = &iov, .msg_iovlen = 1,
+ .msg_name = (void *)&peer_sa[device], .msg_namelen = sizeof(peer_sa[0])
+ };
+ int len;
+ fd_set read_fds;
+ struct timeval tv;
+ bcmos_errno err;
+ int rc;
+
+ FD_ZERO(&read_fds);
+ FD_SET(sock, &read_fds);
+ tv.tv_sec = 0;
+ tv.tv_usec = BCMTR_MSG_TIMEOUT * 1000;
+
+ rc = select(sock + 1, &read_fds, NULL, NULL, &tv);
+ if (rc < 0)
+ {
+ perror("select");
+ return BCM_ERR_COMM_FAIL;
+ }
+ if (!rc || !FD_ISSET(sock, &read_fds))
+ {
+ return BCM_ERR_TIMEOUT;
+ }
+
+ err = bcmolt_buf_alloc(buf, BCMTR_MAX_MTU_SIZE, BCMOLT_BUF_ENDIAN_FIXED);
+ if (err)
+ return BCM_ERR_NOMEM;
+
+ iov.iov_base = buf->start;
+ iov.iov_len = BCMTR_MAX_MTU_SIZE;
+ len = recvmsg(sock, &msg, 0);
+ if (len <= 0)
+ {
+ _bcmtr_udp_print_err(BCM_ERR_COMM_FAIL, "recvmsg() failed\n");
+ bcmolt_buf_free(buf);
+ return BCM_ERR_COMM_FAIL;
+ }
+ buf->len = len;
+ *subch = ntohs(peer_sa[device].sin_port);
+
+ return BCM_ERR_OK;
+}
+
+/** Initialize plugin callbacks
+ * \param[in,out] driver Transport plugin driver structure
+ * \return error code
+ */
+bcmos_errno bcmtr_plugin_init(bcmtr_plugin_cfg *cfg, bcmtr_driver *driver)
+{
+ if (cfg->type != BCMTR_TYPE_UDP)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_PARM, "Invalid plugin type. Expected UDP\n");
+ }
+
+ driver->open = bcmtr_udp_open;
+ driver->close = bcmtr_udp_close;
+ driver->recv = bcmtr_udp_recv;
+ driver->send = bcmtr_udp_send;
+
+ return BCM_ERR_OK;
+}
+
diff --git a/bcm68620_release/release/host_customized/transport/unix_socket/Makefile b/bcm68620_release/release/host_customized/transport/unix_socket/Makefile
new file mode 100644
index 0000000..911e3cc
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/unix_socket/Makefile
@@ -0,0 +1,10 @@
+# UD transport driver
+#
+ifneq ("$(SIMULATION_BUILD)", "y")
+MOD_NAME = udtr
+MOD_TYPE = lib
+MOD_DEPS = trmux tr_plugin_raw_ud
+
+srcs = bcmolt_tr_ud_driver.c
+
+endif
diff --git a/bcm68620_release/release/host_customized/transport/unix_socket/bcmolt_tr_ud_driver.c b/bcm68620_release/release/host_customized/transport/unix_socket/bcmolt_tr_ud_driver.c
new file mode 100755
index 0000000..30143da
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/unix_socket/bcmolt_tr_ud_driver.c
@@ -0,0 +1,231 @@
+/*
+<: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_tr_ud_driver.c
+ *
+ * Unix Domain socket based transport.
+ *
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdlib.h>
+
+#include <bcmolt_tr_mux.h>
+#include <bcmolt_tr_ud_driver.h>
+#include <bcmolt_tr_ud.h>
+
+#define BCMTR_MEM_PACKETS 10000
+#define BCMTR_MEM_OVERHEAD 1024
+#define BCMTR_MIN_RCVBUF_SIZE (BCMTR_MEM_PACKETS * BCMTR_MEM_OVERHEAD)
+
+char socket_path[] = SOCKET_PATH;
+
+typedef struct ud_conn_info {
+ bcmtrmux_channel channel[BCMTR_MAX_OLTS];
+ int sock;
+} ud_conn_info;
+
+static bcmos_task rx_thread;
+static int fd;
+static ud_conn_info *conn_info[BCMTRMUX_MAX_CHANNELS];
+static int ii;
+
+static void _bcmtr_ud_recv(bcmolt_devid device, bcmos_buf *buf, bcmtrmux_channel channel, void *data)
+{
+ uint32_t data_length = bcmos_buf_length(buf);
+ int kk;
+
+ /* Find the socket to respond on... */
+ for (kk=0; kk<sizeof(conn_info)/sizeof(conn_info[0]); kk++)
+ {
+ if (conn_info[kk]->channel[device] == channel)
+ {
+ int len = 0;
+ bcmos_printf("Sending to user application for index %d...", kk);
+ len = send(conn_info[kk]->sock, bcmos_buf_data(buf), data_length, 0);
+ if (len < 0)
+ {
+ bcmos_printf("Failed to send respose to user application - what now?\n");
+ }
+ bcmos_printf("Sent %d bytes\n", len);
+ break;
+ }
+ }
+}
+
+static int bcmtr_ud_rx_handler(long arg)
+{
+ int rc, jj;
+ bcmos_buf *buf;
+ struct timeval tv;
+ fd_set read_set;
+
+ while (1)
+ {
+ int count;
+ FD_ZERO(&read_set);
+ for (jj=0; jj<sizeof(conn_info)/sizeof(conn_info[0]); jj++)
+ {
+ if (conn_info[jj])
+ {
+ FD_SET(conn_info[jj]->sock, &read_set);
+ }
+ }
+
+ tv.tv_sec = 0; tv.tv_usec = 100000;
+
+ count = select (FD_SETSIZE, &read_set, NULL, NULL, &tv);
+ if (count < 0)
+ break;
+
+ for (jj = 0; jj < sizeof(conn_info)/sizeof(conn_info[0]) ; jj++)
+ {
+ if (conn_info[jj] && FD_ISSET(conn_info[jj]->sock, &read_set))
+ {
+ buf = bcmos_buf_alloc(BCMTR_MAX_MTU_SIZE);
+ if (!buf)
+ {
+ return BCM_ERR_NOMEM;
+ }
+ memset(buf, 0 , sizeof(buf));
+ rc=read(conn_info[jj]->sock, bcmos_buf_data(buf), buf->size);
+ buf->len = rc;
+ buf->data+=BCMUD_TXPREFIX_LEN;
+ if (rc < 0 ) {
+ perror("read");
+ exit(-1);
+ }
+ else if (rc == 0) {
+ close(conn_info[jj]->sock);
+ bcmos_free(conn_info[jj]);
+ conn_info[jj]=0;
+ bcmos_printf("Closing %d\n", jj);
+ }
+ else {
+ bcmolt_devid device = 0; /* How do we get this?
+ Need to stuff it at the begining of the message. */
+ bcmtrmux_rx_from_host(device, conn_info[jj]->channel[device], buf);
+ }
+ }
+ }
+ }
+ return BCM_ERR_OK;
+}
+
+static int next_conn_info(bcmolt_devid device)
+{
+ int jj=0;
+ while (jj<sizeof(conn_info)/sizeof(conn_info[0]))
+ {
+ jj++; ii++;
+ if (ii>sizeof(conn_info)/sizeof(conn_info[0])) ii=0;
+ if (!conn_info[ii]) return 0;
+ }
+ return -1;
+}
+
+bcmos_errno bcmtr_ud_init(void)
+{
+ bcmos_errno err = BCM_ERR_OK;
+ struct sockaddr_un addr;
+ bcmos_task_parm parm = {
+ .priority = TASK_PRIORITY_TRANSPORT_RX,
+ .stack_size = BCMTR_RX_THREAD_STACK,
+ .handler = bcmtr_ud_rx_handler,
+ .name = "ud handler"
+ };
+
+ ii=0;
+
+ if ( (fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
+ perror("socket error");
+ exit(-1);
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sun_family = AF_UNIX;
+ BUG_ON(sizeof(socket_path)>=sizeof(addr.sun_path));
+ memcpy(addr.sun_path, socket_path, sizeof(socket_path));
+
+ if (bind(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
+ perror("bind error");
+ exit(-1);
+ }
+
+ if (listen(fd, 5) == -1) {
+ perror("listen error");
+ exit(-1);
+ }
+
+ err = bcmos_task_create(&rx_thread, &parm);
+
+ if (err) return err;
+
+ while (1) {
+ bcmolt_devid device = 0; /* How do we get this? Need to stuff it at the begining of the message. */
+ int s;
+ ud_conn_info *ci;
+ bcmos_errno rc;
+ bcmtrmux_channel channel = BCMTRMUX_CHANNEL_AUTO_ASSIGN;
+
+ if ( (s = accept(fd, NULL, NULL)) == -1) {
+ perror("accept error");
+ sleep(1);
+ continue;
+ }
+
+ ci = bcmos_calloc(sizeof(*ci));
+ if (!ci)
+ {
+ BCMOS_TRACE_RETURN(BCM_ERR_NOMEM, "No memory\n");
+ }
+ rc = bcmtrmux_channel_register(device, &channel, _bcmtr_ud_recv, conn_info);
+ if (rc)
+ {
+ bcmos_printf("%s: can't register channel for device %u. rc=%d\n", __FUNCTION__, device, (int)rc);
+ return rc;;
+ }
+ ci->sock = s;
+ ci->channel[device]=channel;
+ conn_info[ii] = ci;
+
+ bcmos_printf("Accepting %d-%d\n", ii, conn_info[ii]->sock);
+
+ if (next_conn_info(device) < 0) return -1;
+ }
+ return BCM_ERR_OK;
+}
+
+void bcmtr_ud_exit(void)
+{
+
+}
diff --git a/bcm68620_release/release/host_customized/transport/unix_socket/bcmolt_tr_ud_driver.h b/bcm68620_release/release/host_customized/transport/unix_socket/bcmolt_tr_ud_driver.h
new file mode 100755
index 0000000..9726c9c
--- /dev/null
+++ b/bcm68620_release/release/host_customized/transport/unix_socket/bcmolt_tr_ud_driver.h
@@ -0,0 +1,42 @@
+/*
+<: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.
+
+:>
+ */
+
+/*
+ * bcmtr_ud_driver.h - host unix domain socket transport driver
+ */
+
+#ifndef BCMOLT_TR_UD_DRIVER_H_
+#define BCMOLT_TR_UD_DRIVER_H_
+
+#include <bcmos_system.h>
+
+bcmos_errno bcmtr_ud_init(void);
+void bcmtr_ud_exit(void);
+
+#endif
diff --git a/bcm68620_release/release/host_customized/user_config/Makefile b/bcm68620_release/release/host_customized/user_config/Makefile
new file mode 100644
index 0000000..1db59e8
--- /dev/null
+++ b/bcm68620_release/release/host_customized/user_config/Makefile
@@ -0,0 +1,16 @@
+#
+# user_config
+#
+MOD_NAME = user_config
+MOD_DEPS = common_api fld ll_pcie
+
+ifeq ("$(OS_KERNEL)", "linux")
+ MOD_TYPE = linux_lib
+else
+ MOD_TYPE = lib
+endif
+
+ifneq ("$(BOARD)", "")
+ srcs = board/$(BOARD)/bcmolt_user_utils.c
+ MOD_DEPS += i2c_devs board_selector
+endif
diff --git a/bcm68620_release/release/host_customized/user_config/bcmolt_user_utils.h b/bcm68620_release/release/host_customized/user_config/bcmolt_user_utils.h
new file mode 100644
index 0000000..ff32e36
--- /dev/null
+++ b/bcm68620_release/release/host_customized/user_config/bcmolt_user_utils.h
@@ -0,0 +1,75 @@
+/*
+<: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_USER_UTILS_H_
+#define _BCMOLT_USER_UTILS_H_
+
+#include <bcmolt_model_types.h>
+#include <bcmos_system.h>
+#include <bcmolt_msg.h>
+#include <bcmolt_fld.h>
+
+/* Validate that the given system mode is supported for the given device.
+ * This function returns BCM_ERR_OK if the system mode is valid or a different error code otherwise. */
+bcmos_errno bcmuser_system_mode_validate(bcmolt_devid device, bcmolt_system_mode system_mode);
+
+/* Read file from a file system into a buffer. */
+int bcmuser_image_read(
+ bcmolt_devid device,
+ bcmolt_device_image_type image_type,
+ uint32_t offset,
+ uint8_t *buf,
+ uint32_t buf_size);
+
+/* Turn off the processor of the embedded device. */
+bcmos_errno bcmuser_device_off(bcmolt_devid device);
+
+/* Turn on the processor of the embedded device. */
+bcmos_errno bcmuser_device_on(bcmolt_devid device);
+
+/* Check whether or not the embedded device processor is running. */
+bcmos_errno bcmuser_device_is_running(bcmolt_devid device, bcmos_bool *is_cpu_on);
+
+/* Prepare the PCIe bus for communication with the embedded devices */
+bcmos_errno bcmuser_pcie_prepare(void);
+
+/* Prepare the PCIe channel for communication with the embedded device.
+ * For example, this function may re-enumerate the PCI-E bus. */
+bcmos_errno bcmuser_pcie_channel_prepare(bcmolt_devid device);
+
+bcmos_errno bcmuser_pcie_channel_prepare_for_kt2(bcmolt_devid device);
+
+/* Remove the PCIe channel for communication with the embedded device.
+ * For example, this function may re-enumerate the PCI-E bus. */
+bcmos_errno bcmuser_pcie_channel_remove(bcmolt_devid device);
+
+/* Reset the host processor. */
+bcmos_errno bcmuser_host_reset(void);
+
+#endif
diff --git a/bcm68620_release/release/host_customized/user_config/board/wrx/bcmolt_user_utils.c b/bcm68620_release/release/host_customized/user_config/board/wrx/bcmolt_user_utils.c
new file mode 100644
index 0000000..94f58a9
--- /dev/null
+++ b/bcm68620_release/release/host_customized/user_config/board/wrx/bcmolt_user_utils.c
@@ -0,0 +1,533 @@
+/*
+<: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 <linux/fs.h>
+#include <linux/buffer_head.h>
+#include <linux/reboot.h>
+#include <linux/pci.h>
+#include <asm/segment.h>
+#include <asm/uaccess.h>
+#include <bcmos_system.h>
+#include <bcm_config.h>
+#include <bcmolt_msg.h>
+#include <bcmolt_fld.h>
+#include <bcmolt_llpcie.h>
+#include <bcmolt_conv.h>
+#include <bcmolt_i2c_devs.h>
+#include <bcmolt_board_selector.h>
+#include "bcmolt_user_utils.h"
+
+#define BCM_I2C_DEV_ADDR_START typedef enum {
+#define BCM_I2C_DEV_ADDR(name, desc, val) name = val,
+#define BCM_I2C_DEV_ADDR_END } bcm_i2c_dev_addr;
+#include <bcmolt_i2c_devs_addr.h>
+
+#define BOOT_FILE "/opt/bcm68620/bcm68620_boot.bin"
+#define APPL_FILE "/opt/bcm68620/bcm68620_appl.bin"
+#define ONU_FW_FILE "/opt/bcm68620/dummy_onu_firmware.bin"
+
+#define FPGA_REG_FPGA_VERSION 0x0
+#define FPGA_REG_BOARD_CONF 0x1
+#define FPGA_REG_RESETS 0x2
+
+#define FPGA_RST_BIT_DEVICE 0x0
+#define FPGA_DEVICE_SWITCH 4
+
+#define FPGA_ENABLE_ALL_DEVICES 0x1f
+#define FPGA_ENABLE_SWITCH (1 << FPGA_DEVICE_SWITCH)
+/* For now swap devices for consistency with PCI enumeration */
+#define FPGA_DEVICE_RESET_BIT(dev) (1 << (FPGA_RST_BIT_DEVICE + dev))
+
+/* Minimum required FPGA version for reading default system mode via BOARD_CONF register. */
+#define FPGA_VER_FOR_SVK_CONFIG 6
+
+/* Lock that protects critical sections */
+static bcmos_mutex user_lock;
+static bcmos_bool user_lock_initialized;
+
+typedef enum
+{
+ SVK_BOARD_ID_1 = 0x7, /* SVK #1 - BCM968620S: all PON flavors supported, SFP+ */
+ SVK_BOARD_ID_2_XG = 0x6, /* SVK #2 - BCM968620XG: XGPON */
+ SVK_BOARD_ID_2_XE = 0x5, /* SVK #2 - BCM968620XE: 10G EPON */
+ SVK_BOARD_ID_3 = 0x4, /* SVK #3 - BCM968620K: all PON flavors supported, XFP */
+ DVT_BOARD_ID = 0x3, /* DVT board */
+} svk_board_id;
+
+typedef enum
+{
+ SVK_MODE_GPON_16X = 0xF, /* SVK #1/3: 16x GPON mode, SVK #2: only valid mode */
+ SVK_MODE_EPON_1G_16X = 0xE, /* SVK #1/3: 16x 1G EPON mode */
+ SVK_MODE_XGPON = 0xD, /* SVK #1/3: 8x XGPON mode */
+ SVK_MODE_EPON_10G_8X = 0xC, /* SVK #1/3: 8x 10G EPON mode */
+ SVK_MODE_EPON_GPON_8X = 0xB, /* SVK #1/3: 8x 10G EPON + 8x GPON coexistence mode */
+} svk_mode;
+
+
+#define CHECK_RETURN_ERROR(cond,rc) \
+ do { \
+ if (cond) {\
+ bcmos_printf("%s#%d: failed with rc=%d\n", __FUNCTION__, __LINE__, rc);\
+ return rc;\
+ }\
+ } while (0)
+
+
+static void userlock_lock(void)
+{
+ if (!user_lock_initialized)
+ {
+ bcmos_mutex_create(&user_lock, 0, "reset_lock");
+ user_lock_initialized = BCMOS_TRUE;
+ }
+ bcmos_mutex_lock(&user_lock);
+}
+
+
+static void userlock_unlock(void)
+{
+ bcmos_mutex_unlock(&user_lock);
+}
+
+static struct file *file_open(const char *path, int flags)
+{
+ struct file *fd = NULL;
+ mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+
+ fd = filp_open(path, flags, mode);
+ if(IS_ERR(fd))
+ return NULL;
+ return fd;
+}
+
+static void file_close(struct file *file)
+{
+ filp_close(file, NULL);
+}
+
+static int file_read(struct file *file, uint32_t offset, uint8_t *data, unsigned int size)
+{
+ unsigned long long o = offset;
+ mm_segment_t oldfs;
+ int bytes_read;
+
+ oldfs = get_fs();
+ set_fs(get_ds());
+ bytes_read = vfs_read(file, data, size, &o);
+ set_fs(oldfs);
+ if (bytes_read < 0)
+ {
+ BCMOS_TRACE_ERR("vfs_read returned error %d\n", bytes_read);
+ return (int)BCM_ERR_IO;
+ }
+ return bytes_read;
+}
+
+static int file_write(struct file* file, unsigned long long offset, unsigned char* data, unsigned int size)
+{
+ mm_segment_t oldfs;
+ int ret;
+
+ oldfs = get_fs();
+ set_fs(get_ds());
+
+ ret = vfs_write(file, data, size, &offset);
+
+ set_fs(oldfs);
+ return ret;
+}
+
+static bcmos_errno file_write_1(const char *path)
+{
+ struct file *fd;
+ char to_write[] = { '1' };
+ loff_t pos = 0;
+ ssize_t bytes_written;
+
+ fd = file_open(path, O_WRONLY);
+ if ((fd == NULL) || (fd == (void *)-ENOENT)) /* -ENOENT; No such file or directory */
+ {
+ BCMOS_TRACE_ERR("Can't open file %s for writing. Error %s\n",
+ path, bcmos_strerror(fd == NULL ? BCM_ERR_NULL : BCM_ERR_NOENT));
+ return (fd == NULL ? BCM_ERR_NULL : BCM_ERR_NOENT);
+ }
+
+ bytes_written = file_write(fd, pos, to_write, sizeof(to_write));
+ if (bytes_written != sizeof(to_write))
+ {
+ BCMOS_TRACE_ERR("vfs_write returned incorrect number of characters written: %d\n", bytes_written);
+ }
+
+ file_close(fd);
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno i2c_fpga_read(uint32_t reg, uint32_t *val)
+{
+ return maple_i2c_read_fpga(maple_i2c_get_client(FPGA_I2C_ADDR), reg, val);
+}
+
+static bcmos_errno i2c_fpga_write(uint32_t reg, uint32_t val)
+{
+ return maple_i2c_write_fpga(maple_i2c_get_client(FPGA_I2C_ADDR), reg, val);
+}
+
+static bcmos_errno i2c_config_switch(void)
+{
+ uint8_t to_write = 1;
+ int ret;
+
+ ret = maple_i2c_write(maple_i2c_get_client(I2C_SW0_I2C_ADDR), &to_write, 1);
+ if (ret != 0)
+ {
+ BCMOS_TRACE_ERR("Failed to write switch: %d\n", ret);
+ return BCM_ERR_INTERNAL;
+ }
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_errno i2c_fpga_version_get(uint32_t *version)
+{
+ return i2c_fpga_read(FPGA_REG_FPGA_VERSION, version);
+}
+
+static bcmos_errno i2c_svk_config_get(svk_board_id *board_id, svk_mode *mode)
+{
+ uint32_t val;
+ bcmos_errno rc;
+
+ rc = i2c_fpga_read(FPGA_REG_BOARD_CONF, &val);
+ if (rc == BCM_ERR_OK)
+ {
+ *board_id = (svk_board_id)(val & 0x7);
+ *mode = (svk_mode)((val >> 4) & 0xF);
+ }
+
+ return rc;
+}
+
+static bcmos_errno i2c_device_cpu_state_set(bcmolt_devid device, bcmos_bool is_on)
+{
+ bcmos_errno rc;
+ uint32_t reset_values;
+
+ /* Prevent race condition when this function is called for 2 devices simultaneously */
+ userlock_lock();
+
+ do
+ {
+ rc = i2c_config_switch();
+ if (rc)
+ break;
+
+ /* Read-modify-write so we can set only the relevant bit */
+ rc = i2c_fpga_read(FPGA_REG_RESETS, &reset_values);
+ if (rc)
+ break;
+
+ if (is_on)
+ reset_values |= FPGA_DEVICE_RESET_BIT(device);
+ else
+ reset_values &= ~FPGA_DEVICE_RESET_BIT(device);
+
+ rc = i2c_fpga_write(FPGA_REG_RESETS, reset_values);
+
+ } while (0);
+
+ userlock_unlock();
+
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ bcmos_usleep(1000);
+
+ return BCM_ERR_OK;
+}
+
+static bcmos_bool bcmuser_system_mode_is_valid(bcmolt_system_mode system_mode, svk_board_id board_id, svk_mode svk_mode)
+{
+ switch (board_id)
+ {
+ case SVK_BOARD_ID_1:
+ case SVK_BOARD_ID_3:
+ switch (svk_mode)
+ {
+ case SVK_MODE_GPON_16X:
+ return (system_mode == BCMOLT_SYSTEM_MODE_GPON__4_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_GPON__8_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_GPON__16_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_GPON_8_XGPON_4_X_COEXISTENCE ||
+ system_mode == BCMOLT_SYSTEM_MODE_XGPON_1__8_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_XGPON_1__4_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_NGPON2__8_X_2_P_5_G);
+ case SVK_MODE_EPON_1G_16X:
+ return (system_mode == BCMOLT_SYSTEM_MODE_EPON__4_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_EPON__8_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_EPON__16_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_EPON__2_X_10_G ||
+ system_mode == BCMOLT_SYSTEM_MODE_EPON__4_X_10_G ||
+ system_mode == BCMOLT_SYSTEM_MODE_EPON__8_X_10_G);
+ case SVK_MODE_XGPON:
+ return (system_mode == BCMOLT_SYSTEM_MODE_XGPON_1__8_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_XGPON_1__4_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_NGPON2__8_X_2_P_5_G);
+ case SVK_MODE_EPON_10G_8X:
+ return
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__4_X_COEXISTENCE_TDMA) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__8_X_COEXISTENCE_TDMA) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__2_X_10_G) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__4_X_10_G) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__8_X_10_G);
+ default:
+ return BCMOS_FALSE;
+ }
+ case SVK_BOARD_ID_2_XG:
+ return (system_mode == BCMOLT_SYSTEM_MODE_XGPON_1__8_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_XGPON_1__4_X ||
+ system_mode == BCMOLT_SYSTEM_MODE_NGPON2__8_X_2_P_5_G ||
+ system_mode == BCMOLT_SYSTEM_MODE_XGS__2_X_10_G ||
+ system_mode == BCMOLT_SYSTEM_MODE_NGPON2__2_X_10_G);
+ case SVK_BOARD_ID_2_XE:
+ return
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__4_X_COEXISTENCE_TDMA) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__8_X_COEXISTENCE_TDMA) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_AE_8_X) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__2_X_10_G) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__4_X_10_G) ||
+ (system_mode == BCMOLT_SYSTEM_MODE_EPON__8_X_10_G);
+ case DVT_BOARD_ID:
+ return BCMOS_TRUE;
+ default:
+ return BCMOS_FALSE;
+ }
+}
+
+bcmos_errno bcmuser_system_mode_validate(bcmolt_devid device, bcmolt_system_mode system_mode)
+{
+ bcmos_errno rc;
+ uint32_t version;
+ svk_board_id board_id;
+ svk_mode svk_mode;
+
+ rc = i2c_config_switch();
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ rc = i2c_fpga_version_get(&version);
+ if (rc != BCM_ERR_OK)
+ {
+ BCMOS_TRACE_INFO("Failed to read FPGA version\n");
+ return rc;
+ }
+
+ if (version < FPGA_VER_FOR_SVK_CONFIG)
+ {
+ /* this FPGA version don't support reading the SVK version, so we must assume it's OK */
+ return BCM_ERR_OK;
+ }
+
+ rc = i2c_svk_config_get(&board_id, &svk_mode);
+ if (rc != BCM_ERR_OK)
+ {
+ BCMOS_TRACE_INFO("Failed to read SVK config\n");
+ return rc;
+ }
+
+ if (bcmuser_system_mode_is_valid(system_mode, board_id, svk_mode))
+ {
+ return BCM_ERR_OK;
+ }
+ else
+ {
+ BCMOS_TRACE_INFO(
+ "System mode %s is not supported for board ID %d, SVK mode %d\n",
+ bcmolt_system_mode_name(system_mode),
+ board_id,
+ svk_mode);
+ return BCM_ERR_NOT_SUPPORTED;
+ }
+}
+
+int bcmuser_image_read(bcmolt_devid device, bcmolt_device_image_type image_type,
+ uint32_t offset, uint8_t *buf, uint32_t buf_size)
+{
+ struct file *fd;
+ int bytes_read;
+ bcmos_errno rc;
+ static int2str_t image_type2str[] =
+ {
+ {BCMOLT_DEVICE_IMAGE_TYPE_BOOTLOADER, BOOT_FILE},
+ {BCMOLT_DEVICE_IMAGE_TYPE_APPLICATION, APPL_FILE},
+ {BCMOLT_DEVICE_IMAGE_TYPE_ITU_PON_ONU_FIRMWARE, ONU_FW_FILE},
+ {-1}
+ };
+ const char *filename;
+
+ filename = int2str(image_type2str, image_type);
+ fd = file_open(filename, O_RDONLY);
+ if ((fd == NULL) || (fd == (void *)-ENOENT)) /* -ENOENT; No such file or directory */
+ {
+ rc = (fd == NULL ? BCM_ERR_NULL : BCM_ERR_NOENT);
+ BCMOS_TRACE_ERR("filp_open returned error %s (%d)\n", bcmos_strerror(rc), rc);
+ return rc;
+ }
+ bytes_read = file_read(fd, offset, buf, buf_size);
+ file_close(fd);
+ if (bytes_read < 0)
+ {
+ return (int)BCM_ERR_IO;
+ }
+ return bytes_read;
+}
+
+bcmos_errno bcmuser_device_off(bcmolt_devid device)
+{
+ /* Ignore request for non-existing device */
+ if (device >= bcmolt_board_num_maple_devices())
+ return BCM_ERR_OK;
+ BCMOS_TRACE_INFO("device=%u\n", device);
+ return i2c_device_cpu_state_set(device, BCMOS_FALSE);
+}
+
+bcmos_errno bcmuser_device_on(bcmolt_devid device)
+{
+ bcmos_errno rc;
+
+ BCMOS_TRACE_INFO("device=%u\n", device);
+ if (device >= bcmolt_board_num_maple_devices())
+ return BCM_ERR_RANGE;
+
+ rc = i2c_device_cpu_state_set(device, BCMOS_TRUE);
+ /* Wait a moment to make sure the device is discoverable in case it just booted. */
+ bcmos_usleep(50 * 1000);
+
+ return rc;
+}
+
+bcmos_errno bcmuser_device_is_running(bcmolt_devid device, bcmos_bool *is_running)
+{
+ bcmos_errno rc;
+ uint32_t reset_values;
+ uint32_t version;
+
+ rc = i2c_config_switch();
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ rc = i2c_fpga_version_get(&version);
+ if (rc != BCM_ERR_OK)
+ {
+ BCMOS_TRACE_INFO("Failed to read FPGA version\n");
+ return rc;
+ }
+ if (!bcmolt_board_supports_standalone(version))
+ {
+ /* For older FPGAs that don't support standalone mode, the device is taken out of reset at boot. We need to lie
+ and tell device control that it's not running, so it will be programmed from scratch. */
+ BCMOS_TRACE_INFO("FPGA version %d doesn't support standalone mode\n", version);
+ *is_running = BCMOS_FALSE;
+ return BCM_ERR_OK;
+ }
+
+ rc = i2c_fpga_read(FPGA_REG_RESETS, &reset_values);
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ *is_running = ((reset_values & FPGA_DEVICE_RESET_BIT(device)) != 0);
+
+ return BCM_ERR_OK;
+}
+
+bcmos_errno bcmuser_host_reset(void)
+{
+ bcm_ll_pcie_cleanup();
+ kernel_restart(NULL);
+ return BCM_ERR_OK; /* will never be reached */
+}
+
+bcmos_errno bcmuser_pcie_prepare(void)
+{
+ bcmos_errno rc;
+ uint32_t reset_values;
+ const char *pcie_rescan_file = bcmolt_board_pci_rescan_string_get();
+ int i;
+
+ /* - Take all devices out of reset
+ * - rescan bus
+ * - restore reset value
+ */
+
+ rc = i2c_config_switch();
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ /* Read-modify-write so we can set only the relevant bit */
+ rc = i2c_fpga_read(FPGA_REG_RESETS, &reset_values);
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ rc = i2c_fpga_write(FPGA_REG_RESETS, FPGA_ENABLE_ALL_DEVICES);
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ bcmos_usleep(50000);
+
+ /* Now recan PCI bus */
+ /* Now re-enumerate the PCI bus by writing a 1 to the 'rescan' file. */
+ rc = file_write_1(pcie_rescan_file);
+ if (rc != BCM_ERR_OK)
+ BCMOS_TRACE_ERR("file write returned error %s (%d)\n", bcmos_strerror(rc), rc);
+ bcmos_usleep(100 * 1000);
+
+ /* Now initialize ll_pcie driver and map maple devices */
+ rc = bcm_ll_pcie_init();
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ /* Now restore rest values. Keep switch out of reset */
+ for (i = 0; i < bcmolt_board_num_maple_devices(); i++)
+ {
+ if ((FPGA_DEVICE_RESET_BIT(i) & reset_values) == 0)
+ bcmuser_pcie_channel_remove(i);
+ }
+ rc = i2c_fpga_write(FPGA_REG_RESETS, reset_values | FPGA_ENABLE_SWITCH);
+ CHECK_RETURN_ERROR(rc != BCM_ERR_OK, rc);
+
+ return 0;
+}
+
+bcmos_errno bcmuser_pcie_channel_prepare(bcmolt_devid device)
+{
+ bcmos_errno rc;
+
+ rc = bcm_ll_pcie_dev_enable(device);
+ if (rc)
+ BCMOS_TRACE_ERR("Couldn't prepare device %d. Error %s\n", device, bcmos_strerror(rc));
+
+ return rc;
+}
+
+bcmos_errno bcmuser_pcie_channel_remove(bcmolt_devid device)
+{
+ bcm_ll_pcie_dev_disable(device);
+ return BCM_ERR_OK;
+}
diff --git a/bcm68620_release/release/host_customized/user_config/board_selector/Makefile b/bcm68620_release/release/host_customized/user_config/board_selector/Makefile
new file mode 100644
index 0000000..bfbfe46
--- /dev/null
+++ b/bcm68620_release/release/host_customized/user_config/board_selector/Makefile
@@ -0,0 +1,15 @@
+#
+# board_selector
+#
+MOD_NAME = board_selector
+MOD_SUPPRESS_OS_DEP = y
+
+ifeq ("$(OS_KERNEL)", "linux")
+ MOD_TYPE = linux_lib
+else
+ MOD_TYPE = lib
+endif
+
+ifneq ("$(BOARD)", "")
+ srcs = $(BOARD)/bcmolt_board_selector.c
+endif
diff --git a/bcm68620_release/release/host_customized/user_config/board_selector/bcmolt_board_selector.h b/bcm68620_release/release/host_customized/user_config/board_selector/bcmolt_board_selector.h
new file mode 100644
index 0000000..74a8103
--- /dev/null
+++ b/bcm68620_release/release/host_customized/user_config/board_selector/bcmolt_board_selector.h
@@ -0,0 +1,61 @@
+/*
+<: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_board_selector.h
+ */
+
+#ifndef _BCMOLT_BOARD_SELECTOR_H_
+#define _BCMOLT_BOARD_SELECTOR_H_
+
+#include <bcmos_system.h>
+
+/* bus, devfn --> device mapping table */
+typedef struct
+{
+ int bus;
+ int devfn;
+ int device;
+} bus_devfn_devid;
+
+/* Get PCI rescan string. It is used in linux to rescan PCIe bus */
+const char *bcmolt_board_pci_rescan_string_get(void);
+
+/* Get bus, devfn --> dev_id mapping table.
+ * The table is terminated by row with bus=-1,devfn=-1
+ */
+const bus_devfn_devid *bcmolt_board_pci_map_table_get(void);
+
+/* Return TRUE if board supports Maple-standalone mode */
+bcmos_bool bcmolt_board_supports_standalone(uint32_t version);
+
+/* Returns number of maple devices on the board */
+uint8_t bcmolt_board_num_maple_devices(void);
+
+#endif /* _BCMOLT_BOARD_SELECTOR_H_ */
diff --git a/bcm68620_release/release/host_customized/user_config/board_selector/wrx/bcmolt_board_selector.c b/bcm68620_release/release/host_customized/user_config/board_selector/wrx/bcmolt_board_selector.c
new file mode 100644
index 0000000..c997a12
--- /dev/null
+++ b/bcm68620_release/release/host_customized/user_config/board_selector/wrx/bcmolt_board_selector.c
@@ -0,0 +1,113 @@
+/*
+<: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_board_selector.c
+ */
+
+#include <linux/fs.h>
+#include "bcmolt_board_selector.h"
+
+static bus_devfn_devid bus_devfn_devid_table_svk4[] = {
+ { 5, 0, 0},
+ { 3, 0, 1},
+ {-1,-1,-1},
+};
+
+static bus_devfn_devid bus_devfn_devid_table_svk1_3[] = {
+ { 3, 0, 0},
+ {-1,-1,-1},
+};
+
+#define SVK4_IDENT_FILE "/etc/svk4"
+
+#define PCIE_DEVICE_RESCAN_FILE_SVK4 "/sys/bus/pci/devices/0000:02:00.0/rescan"
+#define PCIE_DEVICE_RESCAN_FILE_SVK1_3 "/sys/bus/pci/devices/0000:02:01.0/rescan"
+
+/* Minimum required FPGA version for standalone mode (host / embedded processors running disconnected). */
+#define FPGA_VER_FOR_STANDALONE 7
+
+static struct file *file_open(const char *path, int flags)
+{
+ struct file *fd = NULL;
+ mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;
+
+ fd = filp_open(path, flags, mode);
+ if(IS_ERR(fd))
+ return NULL;
+ return fd;
+}
+
+static void file_close(struct file *file)
+{
+ filp_close(file, NULL);
+}
+
+static bcmos_bool can_read_file(const char *path)
+{
+ struct file *fd = file_open(path, O_RDONLY);
+ if ((fd == NULL) || (fd == (void *)-ENOENT)) /* -ENOENT; No such file or directory */
+ {
+ return BCMOS_FALSE;
+ }
+
+ file_close(fd);
+ return BCMOS_TRUE;
+}
+
+static bcmos_bool board_is_svk4(void)
+{
+ return can_read_file(SVK4_IDENT_FILE);
+}
+
+/* Get PCI rescan string. It is used in linux to rescan PCIe bus */
+const char *bcmolt_board_pci_rescan_string_get(void)
+{
+ return board_is_svk4() ? PCIE_DEVICE_RESCAN_FILE_SVK4 : PCIE_DEVICE_RESCAN_FILE_SVK1_3;
+}
+
+/* Get bus, devfn --> dev_id mapping table.
+ * The table is terminated by row with bus=-1,devfn=-1
+ */
+const bus_devfn_devid *bcmolt_board_pci_map_table_get(void)
+{
+ return board_is_svk4() ? bus_devfn_devid_table_svk4 : bus_devfn_devid_table_svk1_3;
+}
+
+/* Return TRUE if board supports Maple-standalone mode */
+bcmos_bool bcmolt_board_supports_standalone(uint32_t version)
+{
+ return board_is_svk4() || version >= FPGA_VER_FOR_STANDALONE;
+}
+
+/* Returns number of maple devices on the board */
+uint8_t bcmolt_board_num_maple_devices(void)
+{
+ return board_is_svk4() ? 2 : 1;
+}
diff --git a/bcm68620_release/release/host_customized/utils_linux/Makefile b/bcm68620_release/release/host_customized/utils_linux/Makefile
new file mode 100644
index 0000000..78867d8
--- /dev/null
+++ b/bcm68620_release/release/host_customized/utils_linux/Makefile
@@ -0,0 +1,15 @@
+# Makefile for building utilities as linux module
+#
+ifeq ("$(OS_KERNEL)", "linux")
+
+MOD_NAME = utils_linux
+MOD_TYPE = linux_lib
+srcs = bcmolt_buf.c
+
+# If called by linux kernel builder - add include paths manually.
+# It is not elegant, but we'll not have many linux modules
+ifneq ("$(KBUILD_SRC)", "")
+ -include $(OUT_DIR_BASE)/Makefile.config.$(MOD_NAME)
+endif
+
+endif
diff --git a/bcm68620_release/release/host_customized/utils_linux/bcmolt_buf.c b/bcm68620_release/release/host_customized/utils_linux/bcmolt_buf.c
new file mode 120000
index 0000000..f7b8320
--- /dev/null
+++ b/bcm68620_release/release/host_customized/utils_linux/bcmolt_buf.c
@@ -0,0 +1 @@
+../../host_driver/utils/bcmolt_buf.c
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/utils_linux/bcmolt_buf.h b/bcm68620_release/release/host_customized/utils_linux/bcmolt_buf.h
new file mode 120000
index 0000000..4f773fe
--- /dev/null
+++ b/bcm68620_release/release/host_customized/utils_linux/bcmolt_buf.h
@@ -0,0 +1 @@
+../../host_driver/utils/bcmolt_buf.h
\ No newline at end of file
diff --git a/bcm68620_release/release/host_customized/utils_linux/bcmolt_conv.h b/bcm68620_release/release/host_customized/utils_linux/bcmolt_conv.h
new file mode 120000
index 0000000..6fb8c97
--- /dev/null
+++ b/bcm68620_release/release/host_customized/utils_linux/bcmolt_conv.h
@@ -0,0 +1 @@
+../../host_driver/utils/bcmolt_conv.h
\ No newline at end of file