Remove unnecessary dependencies in package dectmngr

This reverts commit f01bd18ffc.

ated/Makefile

@@ -1,16 +1,16 @@
-/* 
- * Copyright (C) 2019 iopsys Software Solutions AB. All rights reserved.
- *
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
+#
+# Copyright (C) 2019 iopsys Software Solutions AB. All rights reserved.
+#
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# version 2 as published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
 
 include $(TOPDIR)/rules.mk
 include $(INCLUDE_DIR)/kernel.mk

bbf/Makefile

@@ -1,41 +1,59 @@
 #
-# Copyright (C) 2019 Iopsys
+# Copyright (C) 2019 IOPSYS
 #
 
 include $(TOPDIR)/rules.mk
 
 PKG_NAME:=libbbfdm
-PKG_VERSION:=1.0-2019-10-01
+PKG_VERSION:=2.5-2020-10-26
 PKG_FIXUP:=autoreconf
 PKG_SOURCE_URL:=https://dev.iopsys.eu/iopsys/bbf.git
 PKG_SOURCE_PROTO:=git
-PKG_SOURCE_VERSION:=b3bae9df19df35075ac52f53758288d8e0573790
+PKG_SOURCE_VERSION:=b0cd55880850efc7995f8cb82ac6dd55e75c7b97
 PKG_RELEASE=$(PKG_SOURCE_VERSION)
 PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION)-$(PKG_SOURCE_VERSION).tar.gz
 PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
 
 PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION)
 
-PKG_LICENSE:=GPLv2
+PKG_LICENSE:=LGPL-2.1
 PKG_LICENSE_FILES:=LICENSE
 
 include $(INCLUDE_DIR)/package.mk
 
+define Package/libbbf_api
+  SECTION:=libs
+  CATEGORY:=Libraries
+  TITLE:=Library for libbbfdm API
+  DEPENDS:=+libuci +libubox +libubus +libblobmsg-json +libjson-c
+endef
+
 define Package/libbbfdm
   SECTION:=libs
   CATEGORY:=Libraries
   TITLE:=Library for broadband-forum data model
-  DEPENDS:=+libuci +libubox +libubus +libblobmsg-json +libjson-c +libtrace
+  DEPENDS:=+libuci +libubox +libubus +libblobmsg-json +libjson-c +libtrace +libbbf_api +libopenssl +libmbedtls
 endef
 
 define Package/libbbfdm/config
 	source "$(SOURCE)/Config_bbfdm.in"
 endef
 
-define Package/libbbfdm/description
- Test description will update later.
+define Package/libbbf_api/description
+ Library contains the API(UCI, UBUS, JSON, CLI and Browse) of libbbfdm
 endef
 
+define Package/libbbfdm/description
+ Library contains the data model tree. It includes TR181, TR104, TR143, TR157 and TR064 data models
+endef
+
+USE_LOCAL=$(shell ls ./src/ 2>/dev/null >/dev/null && echo 1)
+ifneq ($(USE_LOCAL),)
+define Build/Prepare
+	$(CP) ./src/* $(PKG_BUILD_DIR)/
+endef
+endif
+
 TARGET_CFLAGS += -DCUSTOM_PREFIX=\\\"$(CONFIG_LIBBBFDM_VENDOR_PREFIX)\\\"
 
 TARGET_CFLAGS += \
@@ -66,22 +84,43 @@ CONFIGURE_ARGS += \
 	--enable-tr064
 endif
 
+ifeq ($(CONFIG_PACKAGE_libopenssl),y)
+CONFIGURE_ARGS += \
+	--enable-libopenssl
+endif
+
+ifeq ($(CONFIG_PACKAGE_libmbedtls),y)
+CONFIGURE_ARGS += \
+	--enable-libmbedtls
+endif
+
+define Package/libbbf_api/install
+	$(INSTALL_DIR) $(1)/lib
+	$(CP) $(PKG_BUILD_DIR)/bin/.libs/libbbf_api.so* $(1)/lib/
+endef
+
 define Package/libbbfdm/install
 	$(INSTALL_DIR) $(1)/lib
 	$(CP) $(PKG_BUILD_DIR)/bin/.libs/libbbfdm.so* $(1)/lib/
 	$(INSTALL_DIR) $(1)/etc/bbfdm
+	$(INSTALL_DIR) $(1)/etc/bbfdm/json
 	$(INSTALL_CONF) $(PKG_BUILD_DIR)/config/dmmap $(1)/etc/bbfdm
 	$(INSTALL_DIR) $(1)/usr/share/bbfdm
 	$(CP) $(PKG_BUILD_DIR)/scripts/functions $(1)/usr/share/bbfdm
+	$(INSTALL_DIR) $(1)/usr/lib/bbfdm
 endef
 
 define Build/InstallDev
-	$(INSTALL_DIR) $(1)/usr/include
 	$(INSTALL_DIR) $(1)/usr/include/libbbfdm
+	$(INSTALL_DIR) $(1)/usr/include/libbbf_api
 	$(CP) $(PKG_BUILD_DIR)/*.h $(1)/usr/include/libbbfdm/
 	$(CP) $(PKG_BUILD_DIR)/dmtree/tr181/*.h $(1)/usr/include/libbbfdm/
+	$(CP) $(PKG_BUILD_DIR)/dmtree/tr157/*.h $(1)/usr/include/libbbfdm/
+	$(CP) $(PKG_BUILD_DIR)/libbbf_api/*.h $(1)/usr/include/libbbf_api/
 	$(INSTALL_DIR) $(1)/usr/lib
 	$(CP) $(PKG_BUILD_DIR)/bin/.libs/libbbfdm.{a,so*} $(1)/usr/lib/
+	$(CP) $(PKG_BUILD_DIR)/bin/.libs/libbbf_api.{a,so*} $(1)/usr/lib/
 endef
 
+$(eval $(call BuildPackage,libbbf_api))
 $(eval $(call BuildPackage,libbbfdm))

bulkdata/Makefile

@@ -0,0 +1,44 @@
+#
+# Copyright (C) 2020 iopsys Software Solutions AB
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=bulkdata
+PKG_VERSION:=1.0.0
+
+PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_NAME)-$(PKG_VERSION)
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/$(PKG_NAME)
+  SECTION:=utils
+  CATEGORY:=Utilities
+  SUBMENU:=TRx69
+  TITLE:=BBF BulkData Collection
+  DEPENDS:=+libubus +libuci +libubox +libjson-c +libcurl +curl +libblobmsg-json +libbbfdm +libbbf_api
+endef
+
+define Package/$(PKG_NAME)/description
+	BBF BulkData Collection
+endef
+
+define Build/Prepare
+	$(CP) ./src/* $(PKG_BUILD_DIR)/
+endef
+
+TARGET_CFLAGS += \
+	-D_GNU_SOURCE
+
+define Package/$(PKG_NAME)/install
+	$(INSTALL_DIR) $(1)/usr/sbin
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/bulkdatad $(1)/usr/sbin/
+	$(INSTALL_DIR) $(1)/usr/lib/bbfdm
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/*.so $(1)/usr/lib/bbfdm
+	$(CP) ./files/* $(1)/
+endef
+
+$(eval $(call BuildPackage,$(PKG_NAME)))

bulkdata/files/etc/config/bulkdata

@@ -0,0 +1,43 @@
+
+config bulkdata 'bulkdata'
+	option enable '0'
+	#Log levels: Critical=0, Warning=1, Notice=2, Info=3, Debug=4
+	option log_level '3'
+
+config profile
+	option profile_id '1'
+	option enable '0'
+	option name ''
+	option nbre_of_retained_failed_reports '0'
+	option protocol 'http'
+	option encoding_type ''
+	option reporting_interval '86400'
+	option time_reference '0'
+	option csv_encoding_field_separator ','
+	option csv_encoding_row_separator '
'
+	option csv_encoding_escape_character '"'
+	option csv_encoding_report_format 'column'
+	option csv_encoding_row_time_stamp 'unix'
+	option json_encoding_report_format 'objecthierarchy'
+	option json_encoding_report_time_stamp 'unix'
+	option http_url ''
+	option http_username ''
+	option http_password ''
+	option http_compression 'none'
+	option http_method 'post'
+	option http_use_date_header '1'
+	option http_retry_enable '0'
+	option http_retry_minimum_wait_interval '5'
+	option http_retry_interval_multiplier '2000'
+	option http_persist_across_reboot '0'
+
+config profile_parameter
+	option profile_id '1'
+	option name ''
+	option reference ''
+
+config profile_http_request_uri_parameter
+	option profile_id '1'
+	option name ''
+	option reference ''
+

bulkdata/files/etc/init.d/bulkdatad

@@ -0,0 +1,34 @@
+#!/bin/sh /etc/rc.common
+# Bulkdata Software
+# Copyright (C) 2020 iopsys Software Solutions AB
+# Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+
+START=99
+STOP=10
+
+USE_PROCD=1
+PROG="/usr/sbin/bulkdatad"
+
+start_service() {
+	local bulkdata_enable=`uci -q get bulkdata.bulkdata.enable`
+	if [ "$bulkdata_enable" = "1" ]; then
+		procd_open_instance
+		procd_set_param command "$PROG"
+		procd_set_param respawn "3" "7" "0"
+		procd_close_instance
+	fi
+}
+
+boot() {
+	start
+}
+
+reload_service() {
+	stop
+	start 
+}
+
+service_triggers()
+{
+	procd_add_reload_trigger bulkdata
+}

bulkdata/src/Makefile

@@ -0,0 +1,23 @@
+PROG = bulkdatad
+LIB = libbulkdata.so
+
+PROG_OBJS = bulkdata.o common.o config.o http.o log.o report.o times.o buci.o
+LIB_OBJS = datamodel.o
+
+PROG_CFLAGS = $(CFLAGS) -Wall -Werror -fPIC
+PROG_LDFLAGS = $(LDFLAGS) -lubus -luci -lubox -ljson-c -lcurl -lblobmsg_json -lbbfdm
+LIB_LDFLAGS = $(LDFLAGS) -lbbf_api
+
+%.o: %.c
+	$(CC) $(PROG_CFLAGS) $(FPIC) -c -o $@ $<
+
+all: $(PROG) $(LIB)
+
+$(PROG): $(PROG_OBJS)
+	$(CC) $(PROG_CFLAGS) -o $@ $^ $(PROG_LDFLAGS)
+
+$(LIB): $(LIB_OBJS)
+	$(CC) $(PROG_CFLAGS) $(LIB_LDFLAGS) -shared -o $@ $^
+
+clean:
+	rm -f *.o $(PROG) $(LIB)

bulkdata/src/buci.c

@@ -0,0 +1,265 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#include <strings.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <errno.h>
+#include <unistd.h>
+#include <ctype.h>
+
+#include "buci.h"
+
+struct uci_context *uci_ctx = NULL;
+
+int buci_init(void)
+{
+	uci_ctx = uci_alloc_context();
+	if (!uci_ctx) {
+		return -1;
+	}
+	return 0;
+}
+
+int buci_fini(void)
+{
+	if (uci_ctx) {
+		uci_free_context(uci_ctx);
+	}
+
+	return 0;
+}
+
+static bool buci_validate_section(const char *str)
+{
+	if (!*str)
+		return false;
+
+	for (; *str; str++) {
+		unsigned char c = *str;
+
+		if (isalnum(c) || c == '_')
+			continue;
+
+		return false;
+	}
+	return true;
+}
+
+static int buci_init_ptr(struct uci_context *ctx, struct uci_ptr *ptr, char *package, char *section, char *option, char *value)
+{
+	memset(ptr, 0, sizeof(struct uci_ptr));
+
+	/* value */
+	if (value) {
+		ptr->value = value;
+	}
+	ptr->package = package;
+	if (!ptr->package)
+		goto error;
+
+	ptr->section = section;
+	if (!ptr->section) {
+		ptr->target = UCI_TYPE_PACKAGE;
+		goto lastval;
+	}
+
+	ptr->option = option;
+	if (!ptr->option) {
+		ptr->target = UCI_TYPE_SECTION;
+		goto lastval;
+	} else {
+		ptr->target = UCI_TYPE_OPTION;
+	}
+
+lastval:
+	if (ptr->section && !buci_validate_section(ptr->section))
+		ptr->flags |= UCI_LOOKUP_EXTENDED;
+
+	return 0;
+
+error:
+	return -1;
+}
+
+struct uci_section *buci_walk_section(char *package, char *section_type, struct uci_section *prev_section)
+{
+	struct uci_ptr ptr;
+	struct uci_element *e;
+	struct uci_section *next_section;
+
+	if (section_type == NULL) {
+		if (prev_section) {
+			e = &prev_section->e;
+			if (e->list.next == &prev_section->package->sections)
+				return NULL;
+			e = container_of(e->list.next, struct uci_element, list);
+			next_section = uci_to_section(e);
+			return next_section;
+		}
+		else {
+			if (buci_init_ptr(uci_ctx, &ptr, package, NULL, NULL, NULL)) {
+				return NULL;
+			}
+			if (uci_lookup_ptr(uci_ctx, &ptr, NULL, true) != UCI_OK) {
+				return NULL;
+			}
+			if (ptr.p->sections.next == &ptr.p->sections)
+				return NULL;
+			e = container_of(ptr.p->sections.next, struct uci_element, list);
+			next_section = uci_to_section(e);
+
+			return next_section;
+		}
+	}
+	else {
+		struct uci_list *ul, *shead = NULL;
+
+		if (prev_section) {
+			ul = &prev_section->e.list;
+			shead = &prev_section->package->sections;
+		}
+		else {
+			if (buci_init_ptr(uci_ctx, &ptr, package, NULL, NULL, NULL)) {
+				return NULL;
+			}
+			if (uci_lookup_ptr(uci_ctx, &ptr, NULL, true) != UCI_OK) {
+				return NULL;
+			}
+			ul = &ptr.p->sections;
+			shead = &ptr.p->sections;
+		}
+		while (ul->next != shead) {
+			e = container_of(ul->next, struct uci_element, list);
+			next_section = uci_to_section(e);
+			if (strcmp(next_section->type, section_type) == 0)
+				return next_section;
+			ul = ul->next;
+		}
+		return NULL;
+	}
+	return NULL;
+}
+
+void buci_print_list(struct uci_list *uh, char **val, char *delimiter)
+{
+	struct uci_element *e;
+	static char buffer[512];
+	char *buf = buffer;
+	*buf = '\0';
+
+	uci_foreach_element(uh, e) {
+		if (*buf) {
+			strcat(buf, delimiter);
+			strcat(buf, e->name);
+		}
+		else {
+			strcpy(buf, e->name);
+		}
+	}
+	*val = buf;
+}
+
+struct uci_element *buci_lookup_list(struct uci_list *list, const char *name)
+{
+	struct uci_element *e;
+
+	uci_foreach_element(list, e) {
+		if (!strcmp(e->name, name))
+			return e;
+	}
+	return NULL;
+}
+
+int uci_lookup_ptr_bysection(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_section *section, char *option, char *value)
+{
+	struct uci_element *e;
+	memset(ptr, 0, sizeof(struct uci_ptr));
+
+	ptr->package = section->package->e.name;
+	ptr->section = section->e.name;
+	ptr->option = option;
+	ptr->value = value;
+	ptr->flags |= UCI_LOOKUP_DONE;
+
+	ptr->p = section->package;
+	ptr->s = section;
+
+	if (ptr->option) {
+		e = buci_lookup_list(&ptr->s->options, ptr->option);
+		if (!e)
+			return UCI_OK;
+		ptr->o = uci_to_option(e);
+		ptr->last = e;
+		ptr->target = UCI_TYPE_OPTION;
+	}
+	else {
+		ptr->last = &ptr->s->e;
+		ptr->target = UCI_TYPE_SECTION;
+	}
+
+	ptr->flags |= UCI_LOOKUP_COMPLETE;
+
+	return UCI_OK;
+}
+
+char *buci_get_value_bysection(struct uci_section *section, char *option)
+{
+	struct uci_ptr ptr;
+	char *val = "";
+
+	if (uci_lookup_ptr_bysection(uci_ctx, &ptr, section, option, NULL) != UCI_OK) {
+		return val;
+	}
+
+	if (!ptr.o)
+		return val;
+
+	if(ptr.o->type == UCI_TYPE_LIST) {
+		buci_print_list(&ptr.o->v.list, &val, " ");
+		return val;
+	}
+
+	if (ptr.o->v.string)
+		return ptr.o->v.string;
+	else
+		return val;
+}
+
+char *buci_get_value(char *package, char *section, char *option)
+{
+	struct uci_ptr ptr;
+	char *val = "";
+
+	if (!section || !option)
+		return val;
+
+	if (buci_init_ptr(uci_ctx, &ptr, package, section, option, NULL)) {
+		return val;
+	}
+	if (uci_lookup_ptr(uci_ctx, &ptr, NULL, true) != UCI_OK) {
+		return val;
+	}
+
+	if (!ptr.o)
+		return val;
+
+	if(ptr.o->type == UCI_TYPE_LIST) {
+		buci_print_list(&ptr.o->v.list, &val, " ");
+		return val;
+	}
+
+	if (ptr.o->v.string)
+		return ptr.o->v.string;
+	else
+		return val;
+}

bulkdata/src/buci.h

@@ -0,0 +1,31 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __BUCI_H
+#define __BUCI_H
+
+#include <uci.h>
+
+int buci_init(void);
+int buci_fini(void);
+struct uci_section *buci_walk_section(char *package, char *section_type, struct uci_section *prev_section);
+void buci_print_list(struct uci_list *uh, char **val, char *delimiter);
+struct uci_element *buci_lookup_list(struct uci_list *list, const char *name);
+int uci_lookup_ptr_bysection(struct uci_context *ctx, struct uci_ptr *ptr, struct uci_section *section, char *option, char *value);
+char *buci_get_value_bysection(struct uci_section *section, char *option);
+char *buci_get_value(char *package, char *section, char *option);
+
+#define buci_foreach_section(package, section_type, section) \
+	for (section = buci_walk_section(package, section_type, NULL); \
+		section != NULL; \
+		section = buci_walk_section(package, section_type, section))
+
+#endif //__BUCI_H

bulkdata/src/bulkdata.c

@@ -0,0 +1,144 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*				Omar Kallel <omar.kallel@pivasoftware.com>
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <libubox/uloop.h>
+
+#include "http.h"
+#include "config.h"
+#include "log.h"
+#include "common.h"
+#include "report.h"
+#include "times.h"
+#include "bulkdata.h"
+
+struct bulkdata bulkdata_main = {0};
+int profiles_number = 0;
+
+void bulkdata_profile_cb(struct uloop_timeout *timeout);
+
+int get_retry_period(int min)
+{
+        srand(time(NULL));
+        return rand()%min + min;
+}
+
+static void bulkdata_run_profiles(struct bulkdata *bulkdata)
+{
+	unsigned int next_period;
+	int i = 0;
+
+	for (i = 0; i < profiles_number; i++) {
+		bulkdata->profile[i].utimer.cb = bulkdata_profile_cb;
+		LIST_HEAD(failedreports);
+		bulkdata->profile[i].failed_reports = &failedreports;
+		next_period = get_next_period(bulkdata->profile[i].time_reference, bulkdata->profile[i].reporting_interval);
+		bulkdata_log(SINFO, "The session of profile_id %d will be start in %d sec", bulkdata->profile[i].profile_id, next_period);
+		uloop_timeout_set(&bulkdata->profile[i].utimer, next_period * 1000);
+	}
+}
+
+int http_send_report(struct profile *profile, char *report)
+{
+	char *msg_in = NULL;
+	int http_code;
+
+	http_client_init(profile);
+	bulkdata_log(SINFO, "Send the report of profile_id %d to Bulkdata Collector", profile->profile_id);
+	http_code = http_send_message(profile, report, strlen(report), &msg_in);
+	http_client_exit();
+	return http_code;
+}
+
+void bulkdata_profile_cb(struct uloop_timeout *timeout)
+{
+	struct profile *profile;
+	unsigned int http_code, retry_period;
+	char *report = NULL;
+
+	profile = container_of(timeout, struct profile, utimer);
+	time_t now = time(NULL);
+
+	bulkdata_log(SINFO, "New session of profile_id %d started", profile->profile_id);
+	if(profile->retry_count == 0 || profile->next_retry > now || !profile->http_retry_enable) //Perdiodic execution
+		create_encoding_bulkdata_report(profile, &report);
+	else
+		create_failed_report(profile, &report);
+
+	bulkdata_log(SDEBUG, "The content of the profile_id report %d is :\n==========\n%s\n==========\n", profile->profile_id, report);
+	http_code= http_send_report(profile, report);
+	if(http_code != 200){
+		if(profile->retry_count == 0 || profile->next_retry > now || !profile->http_retry_enable) {  //Perdiodic execution
+			retry_period = get_retry_period(profile->http_retry_minimum_wait_interval);
+			profile->next_period = now + profile->reporting_interval;
+			profile->next_retry = now + retry_period;
+			profile->retry_count = 1;
+			profile->min_retry = profile->http_retry_minimum_wait_interval * 2;
+			if((profile->next_retry < profile->next_period) && profile->http_retry_enable) {
+				bulkdata_log(SINFO, "Retry session of profile_id %d in %d sec", profile->profile_id, retry_period);
+				uloop_timeout_set(timeout, 1000 * retry_period);
+			}
+			else {
+				bulkdata_log(SINFO, "Start New session of profile_id %d in %d sec", profile->profile_id, profile->reporting_interval);
+				uloop_timeout_set(timeout, 1000 * profile->reporting_interval);
+			}
+		} else { //Retry execution
+			retry_period= get_retry_period(profile->min_retry);
+			profile->min_retry*=2;
+			profile->next_retry+=retry_period;
+			profile->retry_count++;
+			if(profile->next_retry < profile->next_period) {
+				bulkdata_log(SINFO, "Retry session of profile_id %d in %d sec", profile->profile_id, retry_period);
+				uloop_timeout_set(timeout, 1000 * retry_period);
+			}
+			else {
+				bulkdata_log(SINFO, "Retry session of profile_id %d in %d sec", profile->profile_id, (profile->next_period-profile->next_retry+retry_period));
+				uloop_timeout_set(timeout, 1000 * (profile->next_period-profile->next_retry+retry_period));
+			}
+		}
+		if(profile->new_report){
+			bulkdata_add_failed_report(profile, profile->new_report);
+			FREE(profile->new_report);
+		}
+		FREE(report);
+	} else {
+		if(profile->retry_count == 0 || profile->next_retry > now || !profile->http_retry_enable) {
+			bulkdata_log(SINFO, "Start New session of profile_id %d in %d sec", profile->profile_id, profile->reporting_interval);
+			uloop_timeout_set(timeout, 1000 * profile->reporting_interval);
+		}
+		else {
+			bulkdata_log(SINFO, "Retry session of profile_id %d in %d sec", profile->profile_id, (profile->next_period-profile->next_retry));
+			uloop_timeout_set(timeout, 1000 * (profile->next_period-profile->next_retry));
+		}
+		FREE(profile->new_report);
+		FREE(report);
+		empty_failed_reports_list(profile);
+		profile->retry_count= 0;
+	}
+}
+
+int main(void)
+{
+	struct bulkdata *bulkdata = &bulkdata_main;
+	if (bulkdata_config_init(bulkdata) == -1)
+		return -1;
+	bulkdata_log(SINFO, "Start bulkdatad daemon");
+	
+	uloop_init();
+	bulkdata_run_profiles(bulkdata);
+	uloop_run();
+	uloop_done();
+
+	bulkdata_config_fini(bulkdata);
+	bulkdata_log(SINFO, "Stop bulkdatad daemon");
+	return 0;
+}

bulkdata/src/bulkdata.h

@@ -0,0 +1,18 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __BULKDATA_H
+#define __BULKDATA_H
+
+extern struct bulkdata bulkdata_main;
+extern int profiles_number;
+
+#endif /* __BULKDATA_H */

bulkdata/src/bulkdata.md

@@ -0,0 +1,105 @@
+# README #
+
+bulkdatad is an implementation of The HTTP bulk data collection mechanism which is an extended feature of CPE and other agents implementing TR-069(CWMP) or TR-369(USP), defined by the Broadband Forum. It provides a means by which an Auto-Configuration Server (ACS), or USP Controller, can configure an agent to periodically send a JSON or CSV formatted set of Device information to an HTTP server running a data collection application.
+
+## Configuration File ##
+
+The bulkdatad UCI configuration is located in **'/etc/config/bulkdata'**, and contains 4 sections: **bulkdata**, **profile**, **profile\_parameter** and **profile\_http\_request\_uri\_parameter**.
+
+```
+config bulkdata 'bulkdata'
+	option enable '0'
+	option log_level '3'
+
+config profile
+	option profile_id '1'
+	option enable '0'
+	option csv_encoding_row_time_stamp 'unix'
+	option json_encoding_report_time_stamp 'unix'
+	option http_retry_minimum_wait_interval '5'
+	option http_retry_interval_multiplier '2000'
+
+config profile_parameter
+	option profile_id '1'
+	option name ''
+	option reference ''
+
+config profile_http_request_uri_parameter
+	option profile_id '1'
+	option name ''
+	option reference ''
+```
+
+### bulkdata section ###
+
+It defines **bulkdata configuration**: enable and log\_level.
+
+| Name        |  Type   | Description                                                                                     |
+| ----------- | ------- | ----------------------------------------------------------------------------------------------- |
+| `enable`    | boolean | Enables the BulkData feature if set to **1**.                                                     |
+| `log_level` | integer | Specifies the log type to use, by default **'INFO'**. The possible types are **'EMERG', 'ALERT', 'CRITIC' ,'ERROR', 'WARNING', 'NOTICE', 'INFO' and 'DEBUG'**. |
+
+### profile section ###
+
+It defines **the profile section configuration**: enable, name,... The possible options for **profile** section are listed below:
+
+| Name                               |  Type   | Description                                    |
+| ---------------------------------- | ------- | ---------------------------------------------- |
+| `profile_id`                       | integer | The profile id to use. |
+| `enable`                           | boolean | If set to **1**, enables the bulkdata profile. |
+| `name`                             | string  | The name of the profile. |
+| `nbre_of_retained_failed_reports`  | integer | The number of failed reports to be retained and transmitted at the end of the current reporting interval. |
+| `protocol`                         | string  | The protocol used for the collection profile. |
+| `encoding_type`                    | string  | The encoding type used for the collection profile. |
+| `reporting_interval`               | integer | The reporting interval in seconds. |
+| `time_reference`                   | integer | The time reference to determine when the profile will be transmitted to the ACS collector. |
+| `csv_encoding_field_separator`     | string  | The field separator to use when encoding CSV data. |
+| `csv_encoding_row_separator`       | string  | The row separator to use when encoding CSV data. |
+| `csv_encoding_escape_character`    | string  | The escape character to use when encoding CSV data. |
+| `csv_encoding_report_format`       | string  | Describes how reports will be formatted. Two possible formats are supported: **'ParameterPerRow' and 'ParameterPerColumn'**. |
+| `csv_encoding_row_time_stamp`      | string  | The format of the timestamp to use for data inserted into the row. The row time stamp supported are **'Unix-Epoch', 'ISO-8601' and 'None'**. |
+| `json_encoding_report_format`      | string  | Describes the report format. The supported report formats are **'ObjectHierarchy' and 'NameValuePair'**. |
+| `json_encoding_report_time_stamp`  | string  | The format of the timestamp to use for the JSON Object named "CollectionTime". The supported timestamp are **'Unix-Epoch', 'ISO-8601' and 'None'**. |
+| `http_url`                         | string  | The URL of the collection server. |
+| `http_username`                    | string  | The username of the collection server. |
+| `http_password`                    | string  | The password of the collection server. |
+| `http_compression`                 | string  | The HTTP Compression mechanism used by the collection server. The supported compression mechanism are **'GZIP', 'Compress' and 'Deflate'**. |
+| `http_method`                      | string  | The HTTP method used by the collection server. Two methods are supported: **'POST' and 'PUT'**. |
+| `http_use_date_header`             | boolean | If set to **1**, the CPE encodes the HTTP Date Header. |
+| `http_retry_enable`                | boolean | If set to **1**, the CPE retries unsuccessful attempts to transfer data. |
+| `http_retry_minimum_wait_interval` | integer | The data transfer retry wait interval. |
+| `http_retry_interval_multiplier`   | integer | The retry interval multiplier. |
+| `http_persist_across_reboot`       | boolean | If set to **1**, failed data transfers must be persisted across reboots. |
+
+### profile_parameter section ###
+
+It defines **the profile\_parameter section configuration**: profile\_id, name, reference.
+
+| Name         |  Type   | Description                             |
+| ------------ | ------- | --------------------------------------- |
+| `profile_id` | integer | The id of the used profile.             |
+| `name`       | string  | The name of the profile parameter.      |
+| `reference`  | string  | The reference of the profile parameter. |
+
+### profile_http_request_uri_parameter section ###
+
+It defines **the profile\_http\_request\_uri\_parameter section configuration**: profile\_id, name, reference.
+
+| Name         |  Type   | Description                             |
+| ------------ | ------- | --------------------------------------- |
+| `profile_id` | integer | The id of the used profile.             |
+| `name`       | string  | The name of the Request-URI parameter.  |
+| `reference`  | string  | The reference of the profile parameter. |
+
+## Dependencies ##
+
+To successfully build bulkdatad, the following libraries are needed:
+
+| Dependency  | Link                                        | License        |
+| ----------- | ------------------------------------------- | -------------- |
+| libuci      | https://git.openwrt.org/project/uci.git     | LGPL 2.1       |
+| libubox     | https://git.openwrt.org/project/libubox.git | BSD            |
+| libjson-c   | https://s3.amazonaws.com/json-c_releases    | MIT            |
+| libcurl     | https://dl.uxnr.de/mirror/curl              | MIT            |
+| libbbfdm    | https://dev.iopsys.eu/iopsys/bbf.git        | LGPL 2.1       |
+

bulkdata/src/common.c

@@ -0,0 +1,450 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*				Omar Kallel <omar.kallel@pivasoftware.com>
+*/
+
+#include "common.h"
+
+static pathnode *head = NULL;
+static pathnode *temphead = NULL;
+
+int bulkdata_dm_ctx_init(struct dmctx *ctx)
+{
+	struct bulkdata *bulkdata = &bulkdata_main;
+	dm_ctx_init(ctx, DM_CWMP, bulkdata->amd_version, bulkdata->instance_mode);
+	return 0;
+}
+
+int bulkdata_dm_ctx_clean(struct dmctx *ctx)
+{
+	dm_ctx_clean(ctx);
+	return 0;
+}
+
+static char **str_split(const char* str, const char* delim, size_t* numtokens)
+{
+	char *s = strdup(str);
+	size_t tokens_alloc = 1;
+	size_t tokens_used = 0;
+	char **tokens = calloc(tokens_alloc, sizeof(char*));
+	char *token, *strtok_ctx;
+	for (token = strtok_r(s, delim, &strtok_ctx); token != NULL; token = strtok_r(NULL, delim, &strtok_ctx)) {
+		if (tokens_used == tokens_alloc) {
+			tokens_alloc *= 2;
+			tokens = realloc(tokens, tokens_alloc * sizeof(char*));
+		}
+		tokens[tokens_used++] = strdup(token);
+	}
+	// cleanup
+	if (tokens_used == 0) {
+		FREE(tokens);
+	} else {
+		tokens = realloc(tokens, tokens_used * sizeof(char*));
+	}
+	*numtokens = tokens_used;
+	FREE(s);
+	return tokens;
+}
+
+static bool bulkdata_match(const char *string, const char *pattern)
+{
+	regex_t re;
+	if (regcomp(&re, pattern, REG_EXTENDED) != 0) return 0;
+	int status = regexec(&re, string, 0, NULL, 0);
+	regfree(&re);
+	if (status != 0) return false;
+	return true;
+}
+
+static bool is_res_required(char *str, int *start, int *len)
+{
+	char temp_char[NAME_MAX] = {'\0'};
+
+	if (bulkdata_match(str, GLOB_CHAR)) {
+		int s_len = strlen(str);
+		int b_len = s_len, p_len = s_len;
+
+		char *star = strchr(str, '*');
+		if(star)
+			s_len = star - str;
+		*start = MIN(MIN(s_len, p_len), b_len);
+		if (*start == s_len)
+			*len = 1;
+
+		strncpy(temp_char, str+*start, *len);
+
+		if (bulkdata_match(temp_char, "[*+]+"))
+			return true;
+	}
+	*start = strlen(str);
+	return false;
+}
+
+static void insert(char *data, bool active)
+{
+	pathnode *link = (pathnode*) calloc(1, sizeof(pathnode));
+	if(!link) {
+		return;
+	}
+
+	link->ref_path = data;
+
+	if(active) {
+		link->next = head;
+		head = link;
+	} else {
+		link->next = temphead;
+		temphead = link;
+	}
+}
+
+static void swap_heads(void)
+{
+	pathnode *temp = head;
+	head = temphead;
+	temphead = temp;
+}
+
+static void deleteList(void)
+{
+	pathnode *ptr = head, *temp;
+	while(ptr != NULL) {
+		temp = ptr;
+		free(ptr->ref_path);
+		if(ptr->next != NULL) {
+			ptr = ptr->next;
+		} else {
+			ptr = NULL;
+		}
+		free(temp);
+	}
+	head = NULL;
+	swap_heads();
+}
+
+void bulkdata_add_data_to_list(struct list_head *dup_list, char *name, char *value, char *type)
+{
+	struct resultsnode *link;
+	link = calloc(1, sizeof(struct resultsnode));
+	list_add_tail(&link->list, dup_list);
+	link->name = strdup(name);
+	link->data = strdup(value);
+	link->type = strdup(type);
+}
+
+void bulkdata_delete_data_from_list(struct resultsnode *link)
+{
+	list_del(&link->list);
+	FREE(link->name);
+	FREE(link->data);
+	FREE(link->type);
+	FREE(link);
+}
+
+void bulkdata_free_data_from_list(struct list_head *dup_list)
+{
+	struct resultsnode *link;
+	while (dup_list->next != dup_list) {
+		link = list_entry(dup_list->next, struct resultsnode, list);
+		bulkdata_delete_data_from_list(link);
+	}
+}
+
+static bool bulkdata_get(int operation, char *path, struct dmctx *dm_ctx)
+{
+	int fault = 0;
+
+	switch(operation) {
+		case CMD_GET_NAME:
+			fault = dm_entry_param_method(dm_ctx, CMD_GET_NAME, path, "true", NULL);
+			break;
+		case CMD_GET_VALUE:
+			fault = dm_entry_param_method(dm_ctx, CMD_GET_VALUE, path, NULL, NULL);
+			break;
+		default:
+			return false;
+	}
+
+	if (dm_ctx->list_fault_param.next != &dm_ctx->list_fault_param) {
+		return false;
+	}
+	if (fault) {
+		return false;
+	}
+	return true;
+}
+
+char *bulkdata_get_value_param(char *path)
+{
+	struct dmctx ctx = {0};
+	struct dm_parameter *n;
+	char *value = NULL;
+
+	bulkdata_dm_ctx_init(&ctx);
+	if(bulkdata_get(CMD_GET_VALUE, path, &ctx)) {
+		list_for_each_entry(n, &ctx.list_parameter, list) {
+			value = strdup(n->data);
+			break;
+		}
+	}
+	bulkdata_dm_ctx_clean(&ctx);
+	return value;
+}
+
+void bulkdata_get_value(char *path, struct list_head *list)
+{
+	struct dmctx ctx = {0};
+	struct dm_parameter *n;
+
+	bulkdata_dm_ctx_init(&ctx);
+	if(bulkdata_get(CMD_GET_VALUE, path, &ctx)) {
+		list_for_each_entry(n, &ctx.list_parameter, list) {
+			bulkdata_add_data_to_list(list, n->name, n->data, n->type);
+		}
+	}
+	bulkdata_dm_ctx_clean(&ctx);
+}
+
+bool bulkdata_get_name(char *path)
+{
+	struct dmctx ctx = {0};
+	struct dm_parameter *n;
+	bool ret = false;
+
+	bulkdata_dm_ctx_init(&ctx);
+	if(bulkdata_get(CMD_GET_NAME, path, &ctx)) {
+		list_for_each_entry(n, &ctx.list_parameter, list) {
+			insert(strdup(n->name), false);
+		}
+		ret = true;
+	}
+	bulkdata_dm_ctx_clean(&ctx);
+	return ret;
+}
+
+static void fill_node_path(void)
+{
+	pathnode *p=head;
+	while(p!=NULL) {
+		bulkdata_get_name(p->ref_path);
+		p=p->next;
+	}
+	deleteList();
+}
+
+static void bulkdata_filter_results(char *path, int start, int end)
+{
+	int startpos = start, m_index = 0, m_len = 0;
+	char *pp = path + startpos;
+	char exp[NAME_MAX] = {'\0'};
+
+	if(start >= end) {
+		return;
+	}
+
+	if(!is_res_required(pp, &m_index, &m_len)) {
+		//append rest of the path to the final list
+		if(pp == path ) {
+			insert(strdup(pp), true);
+			return;
+		}
+
+		pathnode *p = head;
+		while(p != NULL) {
+			char name[NAME_MAX] = {'\0'};
+			strcpy(name, p->ref_path);
+			strcat(name, pp);
+			insert(strdup(name), false);
+			p = p->next;
+		}
+		deleteList();
+		return;
+	}
+
+	// Get the string before the match
+	char name[NAME_MAX]={'\0'};
+	strncpy(name, pp, m_index);
+
+	pathnode *p = head;
+	if(p == NULL) {
+		insert(strdup(name), false);
+	}
+
+	while(p != NULL) {
+		char ref_name[NAME_MAX] = {'\0'};
+		sprintf(ref_name, "%s%s", p->ref_path, name);
+		insert(strdup(ref_name), false);
+		p = p->next;
+	}
+	deleteList();
+
+	startpos += m_index;
+	strncpy(exp, pp+m_index, m_len);
+	pp = path + startpos;
+	fill_node_path();
+	startpos += 2;
+	bulkdata_filter_results(path, startpos, end);
+}
+
+static void bulkdata_parse_results(struct list_head *list)
+{
+	pathnode *p = head;
+	while(p != NULL) {
+		bulkdata_get_value(p->ref_path, list);
+		p = p->next;
+	}
+	deleteList();
+}
+
+void bulkdata_get_value_results(char *path, struct list_head *list)
+{
+	bulkdata_filter_results(path, 0, strlen(path));
+	bulkdata_parse_results(list);
+}
+
+char *create_request_url(struct profile *profile)
+{
+	int i = 0, http_uri_number = profile->profile_http_request_uri_parameter_number;
+	char *value, *uri_param = NULL, *uri_tmp = NULL, *http_url = NULL; 
+
+	for (i = 0; i < http_uri_number; i++)
+	{
+		if((profile->profile_http_uri_parameter[i].reference == NULL) || (profile->profile_http_uri_parameter[i].name == NULL))
+			continue;
+		value = bulkdata_get_value_param(profile->profile_http_uri_parameter[i].reference);
+		if(!uri_param) {
+			asprintf(&uri_param, "&%s=%s", profile->profile_http_uri_parameter[i].name, value);
+			free(value);
+		}
+		else {
+			uri_tmp = strdup(uri_param);
+			free(uri_param);
+			asprintf(&uri_param, "%s&%s=%s", uri_tmp, profile->profile_http_uri_parameter[i].name, value);
+			free(value);
+			free(uri_tmp);
+		}
+	}
+	if(uri_param) {
+		asprintf(&http_url, "%s%s", profile->http_url, uri_param);
+		free(uri_param);
+	} else {
+		asprintf(&http_url, "%s", profile->http_url);
+	}
+	return http_url;
+}
+
+char *get_bulkdata_profile_parameter_name(char *paramref, char *paramname, char *param)
+{
+	char **paramarr, *idx1 = NULL, *idx2 = NULL, *res = NULL, *instance = NULL, *tmp = NULL, *retparam = NULL, *s = NULL;
+	int i, j = 0;
+	size_t length;
+
+	if(paramname == NULL || strlen(paramname) <= 0)
+		return strdup(param);
+	paramarr = str_split(paramref, "*", &length);
+	res = strdup(paramname);
+	for(i = 0; i < length; i++) {
+		if(i == length - 1)
+			break;
+		j++;
+		idx1 = strstr(param, paramarr[i]);
+		idx2 = strstr(param, paramarr[i+1]);
+		instance = (char*)calloc(idx2 - idx1 - strlen(paramarr[i]) + 1, sizeof(char));
+		memcpy(instance, idx1 + strlen(paramarr[i]), idx2 - idx1 - strlen(paramarr[i]));
+		tmp = strdup(res);
+		FREE(res);
+		asprintf(&res, "%s.%s", tmp, instance);
+		FREE(tmp);
+		FREE(instance);
+	}
+	if ((s = strstr(param,paramarr[j]) ) != NULL && strlen(s) == strlen(paramarr[j]))
+		asprintf(&retparam, "%s", res);
+	else
+		asprintf(&retparam, "%s.%s", res, strstr(param, paramarr[j]) + strlen(paramarr[j]));
+
+	FREE(res);
+	for(int k = 0; k < length; k++)
+		FREE(paramarr[k]);
+	FREE(paramarr);
+
+	return retparam;
+}
+
+void append_string_to_string(char *strappend, char **target)
+{
+	char *tmp = NULL;
+
+	if(strappend == NULL || strlen(strappend) <= 0)
+		return;
+	if(*target == NULL || strlen(*target) <= 0) {
+		*target = strdup(strappend);
+		return;
+	} else {
+		tmp = strdup(*target);
+		FREE(*target);
+	}
+	asprintf(target, "%s%s", tmp, strappend);
+	FREE(tmp);
+}
+
+void bulkdata_add_failed_report(struct profile *profile, char *freport)
+{
+	struct failed_reports *report, *retreport, *rtmp;
+
+	if(profile->nbre_failed_reports < profile->nbre_of_retained_failed_reports || profile->nbre_of_retained_failed_reports < 0) {
+		profile->nbre_failed_reports++;
+	} else {
+		list_for_each_entry_safe(retreport, rtmp, profile->failed_reports, list) {
+			bulkdata_delete_failed_report(retreport);
+			break;
+		}
+	}
+	report = calloc(1, sizeof(struct failed_reports));
+	list_add_tail(&report->list, profile->failed_reports);
+	report->freport= strdup(freport);
+}
+
+void bulkdata_delete_failed_report(struct failed_reports *report)
+{
+	if(report != NULL) {
+		list_del(&report->list);
+		FREE(report->freport);
+		FREE(report);
+	}
+}
+
+struct failed_reports* empty_failed_reports_list(struct profile *profile)
+{
+	struct failed_reports *report, *rtmp;
+
+	if(list_empty(profile->failed_reports))
+		return NULL;
+	list_for_each_entry_safe(report, rtmp, profile->failed_reports, list) {
+		list_del(&report->list);
+		FREE(report->freport);
+		FREE(report);
+	}
+	return NULL;
+}
+
+void add_failed_reports_to_report_csv(struct profile *profile, char **report, int isnext)
+{
+	struct failed_reports *retreport = NULL;
+	int j = 0;
+
+	if(list_empty(profile->failed_reports))
+		return;
+	list_for_each_entry(retreport, profile->failed_reports, list) {
+		if(!j && isnext) {
+			j = 1;
+			continue;
+		}
+		append_string_to_string(retreport->freport, report);
+	}
+}

bulkdata/src/common.h

@@ -0,0 +1,69 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __COMMON_H
+#define __COMMON_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <regex.h>
+#include <sys/param.h>
+
+#include <libubox/blobmsg.h>
+#include <libubox/blobmsg_json.h>
+#include <libubox/utils.h>
+#include <libubus.h>
+
+#include <libbbfdm/dmentry.h>
+#include <libbbfdm/dmbbfcommon.h>
+
+#include "config.h"
+#include "log.h"
+#include "bulkdata.h"
+
+typedef struct pathnode {
+	char *ref_path;
+	struct pathnode *next;
+} pathnode;
+
+typedef struct resultsnode {
+	struct list_head list;
+	char *name;
+	char *data;
+	char *type;
+} resultsnode;
+
+struct failed_reports {
+	struct list_head list;
+	char *freport;
+};
+
+#define GLOB_CHAR "[[+*]+"
+
+int bulkdata_dm_ctx_init(struct dmctx *ctx);
+int bulkdata_dm_ctx_clean(struct dmctx *ctx);
+
+char *bulkdata_get_value_param(char *path);
+void bulkdata_get_value(char *path, struct list_head *list);
+
+void bulkdata_free_data_from_list(struct list_head *dup_list);
+void bulkdata_get_value_results(char *path, struct list_head *list);
+char *create_request_url(struct profile *profile);
+char *get_bulkdata_profile_parameter_name(char *paramref, char *paramname, char *param);
+void append_string_to_string(char *strappend, char **target);
+void bulkdata_add_failed_report(struct profile *profile, char *freport);
+void bulkdata_delete_failed_report(struct failed_reports *report);
+
+struct failed_reports *empty_failed_reports_list(struct profile *profile);
+void add_failed_reports_to_report_csv(struct profile *profile, char **report, int isnext);
+
+#endif //__COMMON_H

bulkdata/src/config.c

@@ -0,0 +1,524 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*				Omar Kallel <omar.kallel@pivasoftware.com>
+*/
+
+#include <stdio.h>
+#include <strings.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <libbbfdm/deviceinfo.h>
+
+#include "log.h"
+#include "config.h"
+#include "buci.h"
+#include "common.h"
+#include "bulkdata.h"
+
+int get_log_level_config(struct bulkdata *bulkdata)
+{
+	char *value = NULL;
+
+	buci_init();
+	value = buci_get_value("bulkdata", "bulkdata", "log_level");
+	if(value != NULL && *value != '\0')
+		bulkdata->log_level = atoi(value);
+	else
+		bulkdata->log_level = DEFAULT_LOGLEVEL;
+	bulkdata_log(SDEBUG,"Log Level of Bulkdata is : %d", bulkdata->log_level);
+	buci_fini();
+	return 0;
+}
+
+int get_amd_version_config(struct bulkdata *bulkdata)
+{
+	char *value = NULL;
+
+	buci_init();
+	value = buci_get_value("cwmp", "cpe", "amd_version");
+	if(value != NULL && *value != '\0')
+		bulkdata->amd_version = atoi(value);
+	else
+		bulkdata->amd_version = DEFAULT_AMD_VERSION;
+	bulkdata_log(SDEBUG,"CWMP Amendment Version is : %d", bulkdata->amd_version);
+	buci_fini();
+	return 0;
+}
+
+int get_instance_mode_config(struct bulkdata *bulkdata)
+{
+	char *value = NULL;
+
+	buci_init();
+	value = buci_get_value("cwmp", "cpe", "instance_mode");
+	if(value != NULL && *value != '\0') {
+		if(!strcmp(value, "InstanceNumber"))
+			bulkdata->instance_mode = INSTANCE_MODE_NUMBER;
+		else
+			bulkdata->instance_mode = INSTANCE_MODE_ALIAS;
+	}
+	else
+		bulkdata->instance_mode = DEFAULT_INSTANCE_MODE;
+	bulkdata_log(SDEBUG,"CWMP Instance Mode is : %d", bulkdata->instance_mode);
+	buci_fini();
+
+	return 0;
+}
+
+int get_device_id_config(struct bulkdata *bulkdata)
+{
+	struct dmctx dmctx = {0};
+
+	bulkdata_dm_ctx_init(&dmctx);
+	bulkdata->device_id.manufacturer_oui = strdup(get_deviceid_manufactureroui());
+	bulkdata->device_id.product_class = strdup(get_deviceid_productclass());
+	bulkdata->device_id.serial_number = strdup(get_deviceid_serialnumber());
+	bulkdata_dm_ctx_clean(&dmctx);
+
+	return 0;
+}
+
+int load_profile_config(struct bulkdata *bulkdata, struct uci_section *s, int i)
+{
+	char *value = NULL;
+
+	value = buci_get_value_bysection(s, "profile_id");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].profile_id = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The profile_id of profile_id %d is : %d", i, bulkdata->profile[i].profile_id);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "nbre_of_retained_failed_reports");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].nbre_of_retained_failed_reports = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The nombre of retained failed reports of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].nbre_of_retained_failed_reports);
+	}
+
+	value = buci_get_value_bysection(s, "protocol");
+	if(value != NULL && *value != '\0' && strcasecmp(value, "http")==0) {
+		bulkdata->profile[i].protocol = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The protocol of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].protocol);
+	} else
+		return -1;
+	
+	value = buci_get_value_bysection(s, "encoding_type");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].encoding_type = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The encoding type of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].encoding_type);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "reporting_interval");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].reporting_interval = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The reporting interval of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].reporting_interval);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "time_reference");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].time_reference = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The time reference of profile_id %d is : %ld", bulkdata->profile[i].profile_id, bulkdata->profile[i].time_reference);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "csv_encoding_field_separator");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].csv_encoding_field_separator = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The csv encoding field separator of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].csv_encoding_field_separator);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "csv_encoding_row_separator");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].csv_encoding_row_separator = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The csv encoding row separator of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].csv_encoding_row_separator);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "csv_encoding_escape_character");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].csv_encoding_escape_character = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The csv encoding escape character of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].csv_encoding_escape_character);
+	}
+
+	value = buci_get_value_bysection(s, "csv_encoding_report_format");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].csv_encoding_report_format = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The csv encoding report format of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].csv_encoding_report_format);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "csv_encoding_row_time_stamp");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].csv_encoding_row_time_stamp = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The csv encoding row time stamp of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].csv_encoding_row_time_stamp);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "json_encoding_report_format");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].json_encoding_report_format = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The json encoding report format of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].json_encoding_report_format);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "json_encoding_report_time_stamp");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].json_encoding_report_time_stamp = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The json encoding report time stamp of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].json_encoding_report_time_stamp);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "http_url");
+	if(value != NULL && *value != '\0') {
+		char *url = NULL;
+		asprintf(&url, "%s?oui=%s&pc=%s&sn=%s", value, bulkdata->device_id.manufacturer_oui, bulkdata->device_id.serial_number, bulkdata->device_id.serial_number);
+		bulkdata->profile[i].http_url = strdup(url);
+		free(url);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP url of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_url);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "http_username");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_username = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP username of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_username);
+	} else {
+		bulkdata->profile[i].http_username = NULL;
+	}
+
+	value = buci_get_value_bysection(s, "http_password");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_password = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP password of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_password);
+	} else {
+		bulkdata->profile[i].http_password = NULL;
+	}
+
+	value = buci_get_value_bysection(s, "http_compression");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_compression = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP compression of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_compression);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "http_method");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_method = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP method of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_method);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "http_use_date_header");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_use_date_header = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP use date header of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_use_date_header);
+	}
+
+	value = buci_get_value_bysection(s, "http_retry_enable");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_retry_enable = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP retry enable of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_retry_enable);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "http_retry_minimum_wait_interval");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_retry_minimum_wait_interval = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP retry minimum wait interval of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_retry_minimum_wait_interval);
+	}
+
+	value = buci_get_value_bysection(s, "http_retry_interval_multiplier");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_retry_interval_multiplier = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP retry interval multiplier of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_retry_interval_multiplier);
+	}
+
+	value = buci_get_value_bysection(s, "http_persist_across_reboot");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_persist_across_reboot = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP persist across reboot of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_persist_across_reboot);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "http_ssl_capath");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_ssl_capath = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP ssl capath of profile_id %d is : %s", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_ssl_capath);
+	} else {
+		bulkdata->profile[i].http_ssl_capath = NULL;
+	}
+
+	value = buci_get_value_bysection(s, "http_insecure_enable");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].http_insecure_enable = atoi(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP insecure enable of profile_id %d is : %d", bulkdata->profile[i].profile_id, bulkdata->profile[i].http_insecure_enable);
+	}
+
+	bulkdata->profile[i].retry_count = 0;
+	bulkdata->profile[i].nbre_failed_reports = 0;
+
+	return 0;
+}
+
+int get_profiles_enable(struct bulkdata *bulkdata)
+{
+	struct uci_section *s;
+	char *enable;
+	int i = 0, nbr_profiles = 0;
+
+	buci_init();
+
+	buci_foreach_section("bulkdata", "profile", s) {
+		enable = buci_get_value_bysection(s, "enable");
+		if(strcmp(enable, "1") == 0) {
+			nbr_profiles++;
+		}
+	}
+
+	if(nbr_profiles != 0)
+		bulkdata->profile = calloc(2, sizeof(struct profile));
+	
+	buci_foreach_section("bulkdata", "profile", s) {
+		enable = buci_get_value_bysection(s, "enable");
+		if(strcmp(enable, "1") == 0) {
+			if(load_profile_config(bulkdata, s, i) == -1) {
+				bulkdata_log(SCRIT,"Not able to start bulkdata: some required bulkdata configurations in profile must be set");
+				return -1;
+			}
+			i++;
+		}
+	}
+	profiles_number = nbr_profiles;
+
+	buci_fini();
+	return 0;
+}
+
+int load_profile_parameter_config(struct bulkdata *bulkdata, struct uci_section *s, int i, int j)
+{
+	char *value = NULL;
+
+	value = buci_get_value_bysection(s, "name");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].profile_parameter[j].name = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The parameter name %d of profile_id %d is : %s", j+1, bulkdata->profile[i].profile_id, bulkdata->profile[i].profile_parameter[j].name);
+	} else {
+		bulkdata->profile[i].profile_parameter[j].name = NULL;
+	}
+
+	value = buci_get_value_bysection(s, "reference");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].profile_parameter[j].reference = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The parameter reference %d of profile_id %d is : %s", j+1, bulkdata->profile[i].profile_id, bulkdata->profile[i].profile_parameter[j].reference);
+	} else
+		return -1;
+
+	return 0;
+}
+
+int get_profiles_parameters(struct bulkdata *bulkdata)
+{
+	struct uci_section *s;
+	char *profile_id;
+	int i, j, nbr_profile_parameters;
+
+	buci_init();
+
+	for (i = 0; i < profiles_number; i++) {
+		j = 0;
+		nbr_profile_parameters = 0;
+		buci_foreach_section("bulkdata", "profile_parameter", s) {
+			profile_id = buci_get_value_bysection(s, "profile_id");
+			if(bulkdata->profile[i].profile_id != atoi(profile_id))
+				continue;
+			nbr_profile_parameters++;
+			if(nbr_profile_parameters == 1) {
+				bulkdata->profile[i].profile_parameter = calloc(1, sizeof(struct profile_parameter));
+			} else {
+				bulkdata->profile[i].profile_parameter = realloc(bulkdata->profile[i].profile_parameter, nbr_profile_parameters * sizeof(struct profile_parameter));
+			}
+			if(load_profile_parameter_config(bulkdata, s, i, j) == -1) {
+				bulkdata_log(SCRIT,"Not able to start bulkdata: some required bulkdata configurations in profile_parameter must be set");
+				return -1;
+			}
+			j++;
+		}
+		bulkdata->profile[i].profile_parameter_number = nbr_profile_parameters;
+	}
+
+	buci_fini();
+	return 0;
+}
+
+int load_profile_http_request_uri_parameter_config(struct bulkdata *bulkdata, struct uci_section *s, int i, int j)
+{
+	char *value = NULL;
+
+	value = buci_get_value_bysection(s, "name");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].profile_http_uri_parameter[j].name = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP resuest URI parameter name %d of profile_id %d is : %s", j+1, bulkdata->profile[i].profile_id, bulkdata->profile[i].profile_http_uri_parameter[j].name);
+	} else
+		return -1;
+
+	value = buci_get_value_bysection(s, "reference");
+	if(value != NULL && *value != '\0') {
+		bulkdata->profile[i].profile_http_uri_parameter[j].reference = strdup(value);
+		value = NULL;
+		bulkdata_log(SDEBUG,"The HTTP resuest URI parameter reference %d of profile_id %d is : %s", j+1, bulkdata->profile[i].profile_id, bulkdata->profile[i].profile_http_uri_parameter[j].reference);
+	} else
+		return -1;
+
+	return 0;
+}
+
+int get_profile_http_request_uri_parameter(struct bulkdata *bulkdata)
+{
+	struct uci_section *s;
+	char *profile_id;
+	int i, j, nbr_profile_http_request_uri_parameter;
+
+	buci_init();
+
+	for (i = 0; i < profiles_number; i++) {
+		j = 0;
+		nbr_profile_http_request_uri_parameter = 0;
+		buci_foreach_section("bulkdata", "profile_http_request_uri_parameter", s) {
+			profile_id = buci_get_value_bysection(s, "profile_id");
+			if(bulkdata->profile[i].profile_id != atoi(profile_id))
+				continue;
+			nbr_profile_http_request_uri_parameter++;
+			if(nbr_profile_http_request_uri_parameter == 1) {
+				bulkdata->profile[i].profile_http_uri_parameter = calloc(1, sizeof(struct profile_http_request_uri_parameter));
+			} else {
+				bulkdata->profile[i].profile_http_uri_parameter = realloc(bulkdata->profile[i].profile_http_uri_parameter, nbr_profile_http_request_uri_parameter * sizeof(struct profile_http_request_uri_parameter));
+			}
+			if(load_profile_http_request_uri_parameter_config(bulkdata, s, i, j)== -1) {
+				bulkdata_log(SCRIT,"Not able to start bulkdata: some required bulkdata configurations in profile_http_request_uri_parameter must be set");
+				return -1;
+			}
+			j++;
+		}
+		bulkdata->profile[i].profile_http_request_uri_parameter_number = nbr_profile_http_request_uri_parameter;
+	}
+
+	buci_fini();
+	return 0;
+}
+
+int bulkdata_config_init(struct bulkdata *bulkdata)
+{
+	get_log_level_config(bulkdata);
+	get_amd_version_config(bulkdata);
+	get_instance_mode_config(bulkdata);
+	get_device_id_config(bulkdata);
+	if (get_profiles_enable(bulkdata) == -1)
+		return -1;
+	if (get_profiles_parameters(bulkdata) == -1)
+		return -1;
+	if (get_profile_http_request_uri_parameter(bulkdata) == -1)
+		return -1;
+	return 0;
+}
+
+int free_device_id_config(struct bulkdata *bulkdata)
+{
+	FREE(bulkdata->device_id.manufacturer_oui);
+	FREE(bulkdata->device_id.product_class);
+	FREE(bulkdata->device_id.serial_number);
+	return 0;
+}
+
+int free_profiles_enable(struct bulkdata *bulkdata)
+{
+	for(int i = 0; i < profiles_number; i++) {
+		FREE(bulkdata->profile[i].protocol);
+		FREE(bulkdata->profile[i].encoding_type);
+		FREE(bulkdata->profile[i].csv_encoding_field_separator);
+		FREE(bulkdata->profile[i].csv_encoding_row_separator);
+		FREE(bulkdata->profile[i].csv_encoding_escape_character);
+		FREE(bulkdata->profile[i].csv_encoding_report_format);
+		FREE(bulkdata->profile[i].csv_encoding_row_time_stamp);
+		FREE(bulkdata->profile[i].json_encoding_report_format);
+		FREE(bulkdata->profile[i].json_encoding_report_time_stamp);
+		FREE(bulkdata->profile[i].http_url);
+		FREE(bulkdata->profile[i].http_username);
+		FREE(bulkdata->profile[i].http_password);
+		FREE(bulkdata->profile[i].http_compression);
+		FREE(bulkdata->profile[i].http_method);
+		FREE(bulkdata->profile[i].http_ssl_capath);
+	}
+	FREE(bulkdata->profile);
+	return 0;
+}
+
+int free_profiles_parameters(struct bulkdata *bulkdata)
+{
+	for(int i = 0; i < profiles_number; i++) {
+		for(int j = 0; j < bulkdata->profile[i].profile_parameter_number; j++) {
+			FREE(bulkdata->profile[i].profile_parameter[j].name);
+			FREE(bulkdata->profile[i].profile_parameter[j].reference);
+		}
+		FREE(bulkdata->profile[i].profile_parameter);
+	}
+	return 0;
+}
+
+int free_profile_http_request_uri_parameter(struct bulkdata *bulkdata)
+{
+	for(int i = 0; i < profiles_number; i++) {
+		for(int j = 0; j < bulkdata->profile[i].profile_http_request_uri_parameter_number; j++) {
+			FREE(bulkdata->profile[i].profile_http_uri_parameter[j].name);
+			FREE(bulkdata->profile[i].profile_http_uri_parameter[j].reference);
+		}
+		FREE(bulkdata->profile[i].profile_http_uri_parameter);
+	}
+	return 0;
+}
+
+int bulkdata_config_fini(struct bulkdata *bulkdata)
+{
+	free_device_id_config(bulkdata);
+	free_profiles_parameters(bulkdata);
+	free_profile_http_request_uri_parameter(bulkdata);
+	free_profiles_enable(bulkdata);
+	return 0;
+}

bulkdata/src/config.h

@@ -0,0 +1,103 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __CONFIG_H
+#define __CONFIG_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <time.h>
+#include <libubox/uloop.h>
+
+#define DEFAULT_AMD_VERSION 2
+#define DEFAULT_INSTANCE_MODE 0
+
+typedef struct device_id {
+	char *manufacturer_oui;
+	char *product_class;
+	char *serial_number;
+} device_id;
+
+typedef struct profile_parameter {
+	int profile_id;
+	char *name;
+	char *reference;
+} profile_parameter;
+
+typedef struct profile_http_request_uri_parameter {
+	int profile_id;
+	char *name;
+	char *reference;
+} profile_http_request_uri_parameter;
+
+typedef struct profile {
+	struct uloop_timeout utimer;
+	int profile_id;
+	int nbre_of_retained_failed_reports;
+	int nbre_failed_reports;
+	int reporting_interval;
+	int profile_parameter_number;
+	int profile_http_request_uri_parameter_number;
+	int http_retry_minimum_wait_interval;
+	int http_retry_interval_multiplier;
+	int min_retry;
+	int retry_count;
+	char *protocol;
+	char *encoding_type;
+	char *csv_encoding_field_separator;
+	char *csv_encoding_row_separator;
+	char *csv_encoding_escape_character;
+	char *csv_encoding_report_format;
+	char *csv_encoding_row_time_stamp;
+	char *json_encoding_report_format;
+	char *json_encoding_report_time_stamp;
+	char *http_url;
+	char *http_username;
+	char *http_password;
+	char *http_compression;
+	char *http_method;
+	char *http_ssl_capath;
+	char *new_report;
+	time_t time_reference;
+	time_t next_retry;
+	time_t next_period;
+	bool http_persist_across_reboot;
+	bool http_insecure_enable;
+	bool enable;
+	bool http_use_date_header;
+	bool http_retry_enable;
+	struct profile_parameter *profile_parameter;
+	struct profile_http_request_uri_parameter *profile_http_uri_parameter;
+	struct list_head *failed_reports;
+} profile;
+
+typedef struct bulkdata {
+	struct device_id							device_id;
+	struct profile								*profile;
+	int 										log_level;
+	int 										amd_version;
+	unsigned int 								instance_mode;
+} bulkdata;
+
+int bulkdata_config_init(struct bulkdata *bulkdata);
+int bulkdata_config_fini(struct bulkdata *bulkdata);
+
+#ifndef FREE
+#define FREE(x) do { if(x) {free(x); x = NULL;} } while (0)
+#endif
+
+#endif //__CONFIG_H
+
+
+
+
+

bulkdata/src/datamodel.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2020 iopsys Software Solutions AB
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 2.1
+ * as published by the Free Software Foundation
+ *
+ *		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+ */
+
+#ifndef _BULKDATA_H_
+#define _BULKDATA_H_
+
+#include <libbbf_api/dmcommon.h>
+
+extern DMOBJ tDeviceBulkDataObj[];
+extern DMOBJ tBulkDataObj[];
+extern DMLEAF tBulkDataParams[];
+extern DMOBJ tBulkDataProfileObj[];
+extern DMLEAF tBulkDataProfileParams[];
+extern DMLEAF tBulkDataProfileParameterParams[];
+extern DMLEAF tBulkDataProfileCSVEncodingParams[];
+extern DMLEAF tBulkDataProfileJSONEncodingParams[];
+extern DMOBJ tBulkDataProfileHTTPObj[];
+extern DMLEAF tBulkDataProfileHTTPParams[];
+extern DMLEAF tBulkDataProfileHTTPRequestURIParameterParams[];
+
+#endif //__BULKDATA_H_
+

bulkdata/src/http.c

@@ -0,0 +1,196 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*				Omar Kallel <omar.kallel@pivasoftware.com>
+*/
+
+#include "http.h"
+
+static struct http_client http_c;
+static CURL *curl;
+
+int http_client_init(struct profile *profile)
+{
+	char *url = create_request_url(profile);
+	if(url) {
+		asprintf(&http_c.url, "%s", url);
+		free(url);
+	}
+	bulkdata_log(SINFO, "ACS url: %s", http_c.url);
+
+	curl_global_init(CURL_GLOBAL_SSL);
+	curl = curl_easy_init();
+	if (!curl) return -1;
+
+	return 0;
+}
+
+void http_client_exit(void)
+{
+	FREE(http_c.url);
+
+	if (http_c.header_list) {
+		curl_slist_free_all(http_c.header_list);
+		http_c.header_list = NULL;
+	}
+
+	curl_easy_cleanup(curl);
+	curl_global_cleanup();
+
+}
+
+static size_t http_get_response(void *buffer, size_t size, size_t rxed, char **msg_in)
+{
+	char *c;
+
+	if (asprintf(&c, "%s%.*s", *msg_in, size * rxed, (char *)buffer) == -1) {
+		FREE(*msg_in);
+		return -1;
+	}
+
+	free(*msg_in);
+	*msg_in = c;
+
+	return size * rxed;
+}
+
+int http_send_message(struct profile *profile, char *msg_out, int msg_out_len, char **msg_in)
+{
+	CURLcode res;
+	long http_code = 0;
+	char errbuf[CURL_ERROR_SIZE];
+
+	http_c.header_list = NULL;
+	http_c.header_list = curl_slist_append(http_c.header_list, "User-Agent: iopsys-bulkdata");
+	if (!http_c.header_list) return -1;
+
+	if (profile->http_use_date_header) {
+		if (bulkdata_get_time() != NULL) {
+			http_c.header_list = curl_slist_append(http_c.header_list, bulkdata_get_time());
+			if (!http_c.header_list) return -1;
+		}
+	}
+
+	if (strcmp(profile->encoding_type, "json") == 0) {
+		http_c.header_list = curl_slist_append(http_c.header_list, "Content-Type: application/json; charset=\"utf-8\"");
+		if (!http_c.header_list) return -1;
+
+		if(strcmp (profile->json_encoding_report_format, "objecthierarchy") == 0) {
+			http_c.header_list = curl_slist_append(http_c.header_list, "BBF-Report-Format: \"ObjectHierarchy\"");
+			if (!http_c.header_list) return -1;
+		} else if(strcmp(profile->json_encoding_report_format, "namevaluepair") == 0) {
+			http_c.header_list = curl_slist_append(http_c.header_list, "BBF-Report-Format: \"NameValuePair\"");
+			if (!http_c.header_list) return -1;
+		}
+	} else if(strcmp(profile->encoding_type, "csv") == 0) {
+		http_c.header_list = curl_slist_append(http_c.header_list, "Content-Type: text/csv; charset=\"utf-8\"");
+		if (!http_c.header_list) return -1;
+
+		if(strcmp (profile->csv_encoding_report_format, "row") == 0) {
+			http_c.header_list = curl_slist_append(http_c.header_list, "BBF-Report-Format: \"ParameterPerRow\"");
+			if (!http_c.header_list) return -1;
+		} else if(strcmp (profile->csv_encoding_report_format, "column") == 0) {
+			http_c.header_list = curl_slist_append(http_c.header_list, "BBF-Report-Format: \"ParameterPerColumn\"");
+			if (!http_c.header_list) return -1;
+		}
+	}
+
+	curl_easy_setopt(curl, CURLOPT_URL, http_c.url);
+	curl_easy_setopt(curl, CURLOPT_USERNAME, profile->http_username);
+	curl_easy_setopt(curl, CURLOPT_PASSWORD, profile->http_password);
+	curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC|CURLAUTH_DIGEST);
+	curl_easy_setopt(curl, CURLOPT_TIMEOUT, HTTP_TIMEOUT);
+	curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, HTTP_TIMEOUT);
+	curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+	curl_easy_setopt(curl, CURLOPT_POSTREDIR, CURL_REDIR_POST_ALL);
+	curl_easy_setopt(curl, CURLOPT_NOBODY, 0);
+
+	if(strcasecmp(profile->http_compression, "gzip") == 0) {
+		curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "gzip");
+		http_c.header_list = curl_slist_append(http_c.header_list, "Content-Encoding: gzip");
+	} else if(strcasecmp(profile->http_compression, "compress") == 0) {
+		curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "compress");
+		http_c.header_list = curl_slist_append(http_c.header_list, "Content-Encoding: compress");
+	} else if(strcasecmp(profile->http_compression, "deflate") == 0) {
+		curl_easy_setopt(curl, CURLOPT_ACCEPT_ENCODING, "deflate");
+		http_c.header_list = curl_slist_append(http_c.header_list, "Content-Encoding: deflate");	
+	}
+
+	curl_easy_setopt(curl, CURLOPT_HTTPHEADER, http_c.header_list);
+	if(strcasecmp(profile->http_method, "put") == 0)
+		curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, msg_out);
+	if (msg_out)
+		curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, (long) msg_out_len);
+	else
+		curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, 0);
+
+	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, http_get_response);
+	curl_easy_setopt(curl, CURLOPT_WRITEDATA, msg_in);
+
+	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbuf);
+	
+	if (profile->http_ssl_capath)
+		curl_easy_setopt(curl, CURLOPT_CAPATH, profile->http_ssl_capath);
+	if (profile->http_insecure_enable) {
+		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
+		curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);		
+	}
+	*msg_in = (char *) calloc (1, sizeof(char));
+
+	res = curl_easy_perform(curl);
+
+	if(res != CURLE_OK) {
+		size_t len = strlen(errbuf);
+		if(len) {
+			if (errbuf[len - 1] == '\n') errbuf[len - 1] = '\0';
+			bulkdata_log(SCRIT, "libcurl: (%d) %s", res, errbuf);
+		} else {
+			bulkdata_log(SCRIT, "libcurl: (%d) %s", res, curl_easy_strerror(res));
+		}
+	}
+
+	if (!strlen(*msg_in))
+		FREE(*msg_in);
+
+	curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
+	if(http_code == 200)
+		bulkdata_log(SINFO, "Receive HTTP 200 OK from Bulkdata Collector");
+	else if(http_code == 401)
+		bulkdata_log(SINFO, "Receive HTTP 401 Unauthorized from Bulkdata Collector");
+	else if(http_code == 204)
+		bulkdata_log(SINFO, "Receive HTTP 204 No Content from Bulkdata Collector");
+	else
+		bulkdata_log(SINFO, "Receive HTTP %d from Bulkdata Collector", http_code);
+
+	if(http_code == 415)
+	{
+		strcpy(profile->http_compression, "None");
+		goto error;
+	}
+	if (http_code != 200 && http_code != 204)
+		goto error;
+
+	curl_easy_reset(curl);
+	if (http_c.header_list) {
+		curl_slist_free_all(http_c.header_list);
+		http_c.header_list = NULL;
+	}
+
+	if (res) goto error;
+
+	return http_code;
+
+error:
+	FREE(*msg_in);
+	if (http_c.header_list) {
+		curl_slist_free_all(http_c.header_list);
+		http_c.header_list = NULL;
+	}
+	return -1;
+}

bulkdata/src/http.h

@@ -0,0 +1,37 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __HTTP_H
+#define __HTTP_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <curl/curl.h>
+#include "config.h"
+#include "log.h"
+#include "times.h"
+#include "common.h"
+
+#define HTTP_TIMEOUT 30
+
+struct http_client
+{
+	struct curl_slist *header_list;
+	char *url;
+};
+
+int http_client_init(struct profile *profile);
+void http_client_exit(void);
+int http_send_message(struct profile *profile, char *msg_out, int msg_out_len, char **msg_in);
+
+#endif //__HTTP_H

bulkdata/src/log.c

@@ -0,0 +1,57 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <syslog.h>
+#include <time.h>
+
+#include "bulkdata.h"
+#include "config.h"
+#include "log.h"
+
+static const int log_syslogmap[] = {
+	[SCRIT] = LOG_CRIT,
+	[SWARNING] = LOG_WARNING,
+	[SNOTICE] = LOG_NOTICE,
+	[SINFO] = LOG_INFO,
+	[SDEBUG] = LOG_DEBUG
+};
+
+static const char* log_str[] = {
+	[SCRIT] = "CRITICAL",
+	[SWARNING] = "WARNING",
+	[SNOTICE] = "NOTICE",
+	[SINFO] = "INFO",
+	[SDEBUG] = "DEBUG"
+};
+
+void bulkdata_log(int priority, const char *format, ...)
+{
+	va_list vl;
+
+	if (priority <= bulkdata_main.log_level) {
+		time_t t = time(NULL);
+		struct tm tm = *localtime(&t);
+		va_start(vl, format);
+		printf("%d-%02d-%02d %02d:%02d:%02d [bulkdata] %s - ", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, log_str[priority]);
+		vprintf(format, vl);
+		va_end(vl);
+		printf("\n");
+
+		openlog("bulkdata", 0, LOG_DAEMON);
+		va_start(vl, format);
+		vsyslog(log_syslogmap[priority], format, vl);
+		va_end(vl);
+		closelog();
+	}
+}

bulkdata/src/log.h

@@ -0,0 +1,28 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __LOG_H
+#define __LOG_H
+
+#define DEFAULT_LOGLEVEL SINFO
+
+enum bulkdata_log_level_enum {
+	SCRIT,
+	SWARNING,
+	SNOTICE,
+	SINFO,
+	SDEBUG,
+	__MAX_SLOG
+};
+
+void bulkdata_log(int priority, const char *format, ...);
+
+#endif //__LOG_H

bulkdata/src/report.c

@@ -0,0 +1,336 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*		Author: Omar Kallel <omar.kallel@pivasoftware.com>
+*
+*/
+
+#include "report.h"
+
+static void add_new_json_obj(json_object *json_obj, char *name, char *data, char *type)
+{
+	json_object *jobj;
+	if(strstr(type, "unsignedInt") || strstr(type, "int") || strstr(type, "long"))
+		jobj = json_object_new_int64(atoi(data));
+	else if(strstr(type, "bool"))
+		jobj = json_object_new_boolean(atoi(data));
+	else
+		jobj = json_object_new_string(data);
+
+	json_object_object_add(json_obj, name, jobj);
+}
+
+static void create_json_bulkdata_report_object_hierarchy(struct profile *profile, char **report)
+{
+	struct json_object *json_obj, *json_obj1, *json_obj2;
+	struct resultsnode *p;
+	int i, j, profile_param_number = profile->profile_parameter_number;
+	char *param_name, *result, *pch, *pchr, *collection_time = NULL;
+	char buf[1024] = {0};
+
+	json_obj = json_object_new_object();
+	get_time_stamp(profile->json_encoding_report_time_stamp, &collection_time);
+	if(collection_time) {
+		if(strcmp(profile->json_encoding_report_time_stamp, "iso8601") == 0)
+			json_object_object_add(json_obj, "CollectionTime", json_object_new_string(collection_time));
+		else
+			json_object_object_add(json_obj, "CollectionTime", json_object_new_int64(atoi(collection_time)));
+		free(collection_time);
+	}
+	json_obj2 = json_obj;
+	for (i = 0; i < profile_param_number; i++) {
+		LIST_HEAD(results_list);
+		bulkdata_get_value_results(profile->profile_parameter[i].reference, &results_list);
+		list_for_each_entry(p, &results_list, list) {
+			char *argv[128] = {0};
+			j = 0;
+			param_name = get_bulkdata_profile_parameter_name(profile->profile_parameter[i].reference, profile->profile_parameter[i].name, p->name);
+			strcpy(buf, param_name);
+			for (pch = strtok_r(buf, ".", &pchr); pch != NULL; pch = strtok_r(NULL, ".", &pchr)) {
+				argv[j] = pch;
+				json_obj1 = (json_object *)dmjson_select_obj(json_obj, argv);
+				if (json_obj1)
+					json_obj2 = json_obj1;
+				else {
+					if (pchr != NULL && *pchr != '\0') {
+						json_object *new_obj = json_object_new_object();
+						json_object_object_add(json_obj2, pch, new_obj);
+						json_obj2 = new_obj;
+					}
+					else
+						add_new_json_obj(json_obj2, pch, p->data, p->type);
+				}
+				j++;
+			}
+		}
+		bulkdata_free_data_from_list(&results_list);
+		FREE(param_name);
+	}
+	result = (char *)json_object_to_json_string_ext(json_obj, JSON_C_TO_STRING_PRETTY);
+	*report = strdup(result);
+	json_object_put(json_obj);
+}
+
+static void create_json_bulkdata_report_name_value_pair(struct profile *profile, char **report)
+{
+	struct json_object *json_obj;
+	struct resultsnode *p;
+	char *param_name, *result, *collection_time = NULL;
+	int i = 0, profile_param_number = profile->profile_parameter_number;
+
+	json_obj = json_object_new_object();
+	get_time_stamp(profile->json_encoding_report_time_stamp, &collection_time);
+	if(collection_time) {
+		if(strcmp(profile->json_encoding_report_time_stamp, "iso8601") == 0)
+			json_object_object_add(json_obj, "CollectionTime", json_object_new_string(collection_time));
+		else
+			json_object_object_add(json_obj, "CollectionTime", json_object_new_int64(atoi(collection_time)));
+		free(collection_time);
+	}
+	for (i = 0; i < profile_param_number; i++) {
+		LIST_HEAD(results_list);
+		bulkdata_get_value_results(profile->profile_parameter[i].reference, &results_list);
+		list_for_each_entry(p, &results_list, list) {
+			param_name = get_bulkdata_profile_parameter_name(profile->profile_parameter[i].reference, profile->profile_parameter[i].name, p->name);
+			add_new_json_obj(json_obj, param_name, p->data, p->type);
+			FREE(param_name);
+		}
+		bulkdata_free_data_from_list(&results_list);
+	}
+	result = (char *)json_object_to_json_string_ext(json_obj, JSON_C_TO_STRING_PRETTY);
+	*report = strdup(result);
+	json_object_put(json_obj);
+}
+
+static void add_failed_reports_to_report_json(struct profile *profile, char *new_report, char **report, int isnext)
+{
+	json_object *json_obj, *json_array, *json_string;
+	struct failed_reports *retreport = NULL;
+	char *msgout = NULL;
+	int j = 0;
+
+	json_obj = json_object_new_object();
+	json_array = json_object_new_array();
+	json_object_object_add(json_obj,"Report", json_array);
+
+	if(list_empty(profile->failed_reports))
+		goto new_report;
+
+	list_for_each_entry(retreport, profile->failed_reports, list) {
+		if(!j && isnext) {
+			j = 1;
+			continue;
+		}
+		json_string = json_tokener_parse(retreport->freport);
+		json_object_array_add(json_array, json_string);
+	}
+
+new_report :
+	if(new_report) {
+		json_string = json_tokener_parse(new_report);
+		json_object_array_add(json_array, json_string);
+	}
+
+	msgout = (char *)json_object_to_json_string_ext(json_obj, JSON_C_TO_STRING_PRETTY);
+	*report = strdup(msgout);
+	json_object_put(json_obj);
+}
+
+static void create_report_json(char *new_report, char **report)
+{
+	json_object *json_obj, *json_array, *json_string;
+	char *msgout = NULL;
+
+	json_obj = json_object_new_object();
+	json_array = json_object_new_array();
+	json_object_object_add(json_obj,"Report", json_array);
+
+	if(new_report) {
+		json_string = json_tokener_parse(new_report);
+		json_object_array_add(json_array, json_string);
+	}
+
+	msgout = (char *)json_object_to_json_string_ext(json_obj, JSON_C_TO_STRING_PRETTY);
+	*report = strdup(msgout);
+	json_object_put(json_obj);
+}
+
+int create_json_bulkdata_report(struct profile *profile, char **report)
+{
+	/*
+	 * create json msg of current report
+	 * parse failed reports list and add it to the report
+	 * then add new report to the report
+	 */
+	char *msgout;
+
+	profile->new_report = NULL;
+	if(strcmp(profile->json_encoding_report_format, "objecthierarchy") == 0) {
+		create_json_bulkdata_report_object_hierarchy(profile, &msgout);
+	} else if(strcmp(profile->json_encoding_report_format, "namevaluepair") == 0) {
+		create_json_bulkdata_report_name_value_pair(profile, &msgout);
+	}
+
+	if(profile->nbre_of_retained_failed_reports != 0) {
+		if(profile->nbre_failed_reports >= profile->nbre_of_retained_failed_reports && profile->nbre_of_retained_failed_reports > 0)
+			add_failed_reports_to_report_json(profile, msgout, report, 1);
+		else
+			add_failed_reports_to_report_json(profile, msgout, report, 0);
+	} else {
+		create_report_json(msgout, report);
+	}
+
+	append_string_to_string(msgout, &profile->new_report);
+	FREE(msgout);
+	return 0;
+}
+
+int create_csv_bulkdata_report(struct profile *profile, char **report)
+{
+	/*
+	 * create csv msg of current report
+	 * parse failed reports list and add it to the report
+	 */
+	int i;
+	struct resultsnode *p;
+	char *str1 = NULL, *str2 = NULL, *str = NULL, *paramprofilename, *timestamp = NULL, *type = NULL, rowseparator = '\0', separator = '\0';
+
+	if(strcmp(profile->csv_encoding_row_separator, "&#10;") == 0)
+		rowseparator = '\n';
+	else if(strcmp(profile->csv_encoding_row_separator, "&#13;") == 0)
+		rowseparator = '\r';
+
+	if(profile->csv_encoding_field_separator)
+		separator = profile->csv_encoding_field_separator[0];
+
+	get_time_stamp(profile->csv_encoding_row_time_stamp, &timestamp);
+	/*
+	 * Create header ReportTimestamp,ParameterName,ParameterValue,ParameterType in case of ParameterPerRow
+	 */
+	if(strcmp(profile->csv_encoding_report_format, "row") == 0) {
+		if(timestamp == NULL)
+			asprintf(&str, "ParameterName%cParameterValue%cParameterType%c", separator, separator, rowseparator);
+		else
+			asprintf(&str, "ReportTimestamp%cParameterName%cParameterValue%cParameterType%c", separator, separator, separator, rowseparator);
+		append_string_to_string(str, report);
+		FREE(str);
+		if(profile->nbre_of_retained_failed_reports != 0) {
+			if(profile->nbre_failed_reports >= profile->nbre_of_retained_failed_reports && profile->nbre_of_retained_failed_reports > 0)
+				add_failed_reports_to_report_csv(profile, report, 1);
+			else
+				add_failed_reports_to_report_csv(profile, report, 0);
+		}
+	}
+	if(strcmp(profile->csv_encoding_report_format, "column") == 0 && timestamp != NULL) {
+		if(profile->nbre_of_retained_failed_reports != 0) {
+			if(profile->nbre_failed_reports >= profile->nbre_of_retained_failed_reports && profile->nbre_of_retained_failed_reports > 0)
+				add_failed_reports_to_report_csv(profile, report, 1);
+			else
+				add_failed_reports_to_report_csv(profile, report, 0);
+		}
+		append_string_to_string("ReportTimestamp", &str1);
+		append_string_to_string(timestamp, &str2);
+	}
+
+	/*
+	 * Add New reports
+	 */
+	profile->new_report = NULL;
+	for(i = 0; i < profile->profile_parameter_number; i++) {
+		LIST_HEAD(results_list);
+		bulkdata_get_value_results(profile->profile_parameter[i].reference, &results_list);
+		list_for_each_entry(p, &results_list, list) {
+			paramprofilename = get_bulkdata_profile_parameter_name(profile->profile_parameter[i].reference, profile->profile_parameter[i].name, p->name);
+			if(strcmp(profile->csv_encoding_report_format, "row") == 0) {
+				type = strstr(p->type, ":");
+				if(timestamp == NULL)
+					asprintf(&str, "%s%c%s%c%s%c", paramprofilename, separator, p->data, separator, type+1, rowseparator);
+				else
+					asprintf(&str, "%s%c%s%c%s%c%s%c", timestamp, separator, paramprofilename, separator, p->data, separator, type+1, rowseparator);
+				append_string_to_string(str, report);
+				append_string_to_string(str, &profile->new_report);
+				FREE(str);
+			} else if(strcmp(profile->csv_encoding_report_format, "column") == 0) {
+				if(str1 == NULL || strlen(str1) <= 0)
+					asprintf(&str, "%s", paramprofilename);
+				else
+					asprintf(&str, "%c%s", separator, paramprofilename);
+				append_string_to_string(str, &str1);
+				FREE(str);
+				if(str2 == NULL || strlen(str2) <= 0)
+					asprintf(&str, "%s", p->data);
+				else
+					asprintf(&str, "%c%s", separator, p->data);
+				append_string_to_string(str, &str2);
+				FREE(str);
+			}
+			FREE(paramprofilename);
+		}
+		bulkdata_free_data_from_list(&results_list);
+	}
+	if(strcmp(profile->csv_encoding_report_format, "column") == 0) {
+		asprintf(&str, "%c", rowseparator);
+		append_string_to_string(str, &str1);
+		append_string_to_string(str, &str2);
+		append_string_to_string(str1, report);
+		append_string_to_string(str2, report);
+		append_string_to_string(str1, &profile->new_report);
+		append_string_to_string(str2, &profile->new_report);
+	}
+	FREE(str);
+	FREE(str1);
+	FREE(str2);
+	FREE(timestamp);
+	return 0;
+}
+
+static void create_json_failed_report(struct profile *profile, char **report)
+{
+	add_failed_reports_to_report_json(profile, NULL, report, 0);
+}
+
+static void create_csv_failed_report(struct profile *profile, char **report)
+{
+	char rowseparator = '\0', separator = '\0', *timestamp = NULL;
+
+	if(strcmp(profile->csv_encoding_row_separator, "&#10;") == 0) {
+		rowseparator = '\n';
+	} else if(strcmp(profile->csv_encoding_row_separator, "&#13;") == 0) {
+		rowseparator = '\r';
+	}
+
+	if(profile->csv_encoding_field_separator)
+		separator = profile->csv_encoding_field_separator[0];
+
+	get_time_stamp(profile->csv_encoding_row_time_stamp, &timestamp);
+	if(strcmp(profile->csv_encoding_report_format, "row") == 0) {
+		if(timestamp == NULL)
+			asprintf(report, "ParameterName%cParameterValue%cParameterType%c", separator, separator, rowseparator);
+		else
+			asprintf(report, "ReportTimestamp%cParameterName%cParameterValue%cParameterType%c", separator, separator, separator, rowseparator);
+	}
+	add_failed_reports_to_report_csv(profile, report, 0);
+}
+
+void create_encoding_bulkdata_report(struct profile *profile, char **report)
+{
+	if(strcasecmp(profile->encoding_type, "json") == 0) {
+		create_json_bulkdata_report(profile, report);
+	} else if(strcasecmp(profile->encoding_type, "csv") == 0) {
+		create_csv_bulkdata_report(profile, report);
+	}
+}
+
+void create_failed_report(struct profile *profile, char **report)
+{
+	if(strcasecmp(profile->encoding_type, "json") == 0) {
+		create_json_failed_report(profile, report);
+	} else if(strcasecmp(profile->encoding_type, "csv") == 0) {
+		create_csv_failed_report(profile, report);
+	}
+}

bulkdata/src/report.h

@@ -0,0 +1,24 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*		Author: Omar Kallel <omar.kallel@pivasoftware.com>
+*
+*/
+
+#ifndef __REPORT_H_
+#define __REPORT_H_
+
+#include <json-c/json.h>
+#include "common.h"
+#include "times.h"
+#include "config.h"
+
+void create_encoding_bulkdata_report(struct profile *profile, char **report);
+void create_failed_report(struct profile *profile, char **report);
+
+#endif /* __REPORT_H_ */

bulkdata/src/times.c

@@ -0,0 +1,62 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+#include "times.h"
+
+const char *bulkdata_get_time(void)
+{
+	static char local_time[64];
+
+	time_t t_time = time(NULL);
+	struct tm *t_tm = localtime(&t_time);
+	if (t_tm == NULL)
+		return NULL;
+
+	if (strftime(local_time, sizeof(local_time),"Date: %a, %d %b %Y %X%z GMT", t_tm) == 0)
+		return NULL;
+
+	return local_time;
+}
+
+void get_time_stamp(const char *format, char **timestamp)
+{
+	time_t now = time(NULL);
+
+	if (strcmp(format, "unix") == 0) {
+		asprintf(timestamp, "%ld", now);
+	} else if (strcmp(format, "iso8601") == 0) {
+		char buf[32] = {0};
+		struct tm *ts = localtime(&now);
+		strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%S%Z", ts);
+		asprintf(timestamp, "%s", buf);
+	} else
+		timestamp = NULL;
+}
+
+unsigned int get_next_period(time_t time_reference, int reporting_interval)
+{
+	unsigned int next_period;
+	time_t now = time(NULL);
+
+	if (now > time_reference)
+		next_period = reporting_interval - ((now - time_reference) % reporting_interval);
+	else
+		next_period = (time_reference - now) % reporting_interval;
+
+	if (next_period == 0)
+		next_period = reporting_interval;
+
+	return next_period;
+}

bulkdata/src/times.h

@@ -0,0 +1,19 @@
+/*
+*	This program is free software: you can redistribute it and/or modify
+*	it under the terms of the GNU General Public License as published by
+*	the Free Software Foundation, either version 2 of the License, or
+*	(at your option) any later version.
+*
+*	Copyright (C) 2020 iopsys Software Solutions AB
+*		Author: Amin Ben Ramdhane <amin.benramdhane@pivasoftware.com>
+*
+*/
+
+#ifndef __TIMES_H
+#define __TIMES_H
+
+const char *bulkdata_get_time(void);
+void get_time_stamp(const char *format, char **timestamp);
+unsigned int get_next_period(time_t time_reference, int reporting_interval);
+
+#endif /* __TIMES_H */

cifsd-tools/Makefile

@@ -0,0 +1,53 @@
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=cifsd-tools
+PKG_RELEASE:=1
+
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=https://github.com/namjaejeon/cifsd-tools.git
+PKG_SOURCE_DATE:=2019-02-14
+PKG_SOURCE_VERSION:=a7d7dfc40524b88dbcb2052034a75f446b3cefdd
+PKG_MIRROR_HASH:=a74f95a79c3cdcc78e66c080729141abee0d821e21a326d88b11d849738314fb
+
+PKG_MAINTAINER:=Andy Walsh <andy.walsh44+github@gmail.com>
+PKG_LICENSE:=GPL-2.0
+PKG_LICENSE_FILES:=COPYING
+
+PKG_INSTALL:=1
+PKG_FIXUP:=autoreconf
+PKG_REMOVE_FILES:=autogen.sh aclocal.m4
+
+include $(INCLUDE_DIR)/package.mk
+include $(INCLUDE_DIR)/nls.mk
+
+define Package/cifsd-tools
+  SECTION:=net
+  CATEGORY:=Network
+  SUBMENU:=Filesystem
+  TITLE:=Kernel CIFS/SMB server support and userspace tools
+  DEPENDS:=+kmod-fs-cifsd +glib2 +libnl-core +libnl-genl $(ICONV_DEPENDS)
+endef
+
+define Package/cifsd-tools/description
+  Userspace tools (cifsd, cifsadmin) for the CIFS/SMB kernel fileserver.
+  The config file location is /etc/cifs/smb.conf
+endef
+
+define Package/cifsd-tools/install
+	$(INSTALL_DIR) $(1)/usr/lib
+	$(CP) $(PKG_INSTALL_DIR)/usr/lib/libcifsdtools.so* $(1)/usr/lib/
+
+	$(INSTALL_DIR) $(1)/etc/cifs
+	$(INSTALL_CONF) $(PKG_BUILD_DIR)/smb.conf.example $(1)/etc/cifs
+
+	$(INSTALL_DIR) $(1)/etc/config
+	$(INSTALL_CONF) ./files/cifsd.config $(1)/etc/config/cifsd
+
+	$(INSTALL_DIR) $(1)/etc/init.d
+	$(INSTALL_BIN) ./files/cifsd.init $(1)/etc/init.d/cifsd
+
+	$(INSTALL_DIR) $(1)/usr/sbin
+	$(INSTALL_BIN) $(PKG_INSTALL_DIR)/usr/sbin/{cifsadmin,cifsd} $(1)/usr/sbin/
+endef
+
+$(eval $(call BuildPackage,cifsd-tools))

cifsd-tools/files/cifsd.config

@@ -0,0 +1,9 @@
+config global 'global'
+	option server_string	'CIFSD on OpenWRT'
+	option ipc_timeout	'8' # IPC timeout is used as a workaround for uninterruptible sleep until this is fixed upstream.
+
+config share
+	option name	'share'
+	option comment	'Default guest share'
+	option path	'/mnt'
+	option guest_ok	'yes'

cifsd-tools/files/cifsd.init

@@ -0,0 +1,161 @@
+#!/bin/sh /etc/rc.common
+
+START=90
+USE_PROCD=1
+PROG=/usr/sbin/cifsd
+USER_DB=/etc/cifs/cifsdpwd.db
+CIFS_ADMIN=cifsadmin
+
+EXTRA_COMMANDS="users"
+EXTRA_HELP="	users	Show list of users created by cifsadmin"
+
+users() {
+	[ -f "$USER_DB" ] && cut -d ':' $USER_DB -f1 || \
+		printf "No users available.\n"
+}
+
+validate_cifsd_global() {
+	uci_validate_section cifsd global global \
+		'server_string:string' \
+		'workgroup:string' \
+		'netbios_name:string' \
+		'interface:string' \
+		'ipc_timeout:uinteger'
+}
+
+validate_cifsd_share() {
+	uci_validate_section cifsd share "${1}" \
+		'name:string' \
+		'comment:string' \
+		'path:string' \
+		'guest_ok:bool' \
+		'read_only:bool' \
+		'allow_hosts:list' \
+		'deny_hosts:list' \
+		'users:string' \
+		'invalid_users:string' \
+		'create_mask:string' \
+		'dir_mask:string' \
+		'max_connections:uinteger' \
+		'veto_files:list'
+}
+
+validate_cifsd_users() {
+	uci_validate_section cifsd users "${1}" \
+		'user:string' \
+		'password:string' \
+		'desc:string'
+}
+
+load_cifsd_global() {
+	local server_string
+	local workgroup
+	local netbios_name
+	local ipc_timeout
+
+	validate_cifsd_global
+
+	echo -e "[global]" >> /var/etc/cifsd.conf
+	[ -n "$server_string" ] && echo -e "\tserver string = $server_string" >> /var/etc/cifsd.conf
+	[ -n "$workgroup" ] && echo -e "\tworkgroup = $workgroup" >> /var/etc/cifsd.conf
+	[ -n "$netbios_name" ] && echo -e "\tnetbios name = $netbios_name" >> /var/etc/cifsd.conf
+	[ -n "$ipc_timeout" ] && echo -e "\tipc timeout name = $ipc_timeout" >> /var/etc/cifsd.conf || \
+		echo -e "\tipc timeout name = 8" >> /var/etc/cifsd.conf
+}
+
+load_cifsd_share() {
+	local name
+	local comment
+	local path
+	local guest_ok
+	local allow_hosts
+	local deny_hosts
+	local users
+	local invalid_users
+	local max_connections
+	local veto_files
+	local dir_mask
+	local create_mask
+	local read_only
+
+	validate_cifsd_share ${1}
+
+	if [ -z "$name" -o -z "$path" ]; then
+		logread -t ${0} "Missing name or path."
+		return
+	fi
+
+	echo -e "\n[$name]\n\tpath = $path" >> /var/etc/cifsd.conf
+	[ -n "$comment" ] && echo -e "\tcomment = $comment" >> /var/etc/cifsd.conf
+	[ -n "$guest_ok" ] && echo -e "\tguest ok = $guest_ok" >> /var/etc/cifsd.conf
+	[ -n "$allow_hosts" ] && echo -e "\tallow hosts = $allow_hosts" >> /var/etc/cifsd.conf
+	[ -n "$deny_hosts" ] && echo -e "\tdeny hosts = $deny_hosts" >> /var/etc/cifsd.conf
+	[ -n "$users" ] && echo -e "\tvalid users = $users" >> /var/etc/cifsd.conf
+	[ -n "$invalid_users" ] && echo -e "\tinvalid users = $invalid_users" >> /var/etc/cifsd.conf
+	[ -n "$max_connections" ] && echo -e "\tmax connections = $max_connections" >> /var/etc/cifsd.conf
+	[ -n "$create_mask" ] && echo -e "\tcreate mask = $create_mask" >> /var/etc/cifsd.conf
+	[ -n "$dir_mask" ] && echo -e "\tdirectory mask = $dir_mask" >> /var/etc/cifsd.conf
+
+	if [ -n "$read_only" ]; then
+		echo -e "\tread only = $read_only" >> /var/etc/cifsd.conf
+		if [ "${read_only}" -eq "0" ]; then
+			echo -e "\twrite ok = 1" >> /var/etc/cifsd.conf
+		fi
+	else
+		echo -e "\twrite ok = 1" >> /var/etc/cifsd.conf
+	fi
+
+	[ -n "$veto_files" ] && echo -e "\tveto files = $veto_files" >> /var/etc/cifsd.conf
+}
+
+load_cifsd_users() {
+	local user
+	local password
+	local desc
+
+	validate_cifsd_users ${1}
+	[ $(which ${CIFS_ADMIN}) ] || {
+		logread -t ${0} "${CIFS_ADMIN} tools is not available"
+		return;
+	}
+
+	cifsadmin -a "${user}" -p "${password}"
+	if [ "$?" -ne 0 ]; then
+		logread -t ${0} "Failed to create/update ${user}"
+	fi
+}
+
+service_triggers()
+{
+	procd_add_config_trigger "config.change" "cifsd" /etc/init.d/cifsd restart
+}
+
+init_config() {
+	[ -f "/var/etc/cifsd.conf" ] && rm /var/etc/cifsd.conf
+
+	config_load cifsd
+	load_cifsd_global
+
+	# Delete existing users
+	[ -f "${USER_DB}" ] && {
+		rm -f "${USER_DB}"
+	}
+	config_foreach load_cifsd_users users
+	config_foreach load_cifsd_share share
+}
+
+start_service() {
+	. /lib/functions.sh
+	init_config
+
+	[ ! "$(grep cifsd /proc/modules)" ] && modprobe cifsd
+	procd_open_instance
+	procd_set_param command /usr/bin/env LANG=en_US.UTF-8 $PROG -c /var/etc/cifsd.conf
+	procd_set_param respawn
+	procd_close_instance
+}
+
+stop_service() {
+	killall cifsd
+	# IPC timeout will kill the remaining processes.
+}

cifsd/001-fix_implicit_declarations.patch

@@ -0,0 +1,73 @@
+For some reason, fs.h on Inteno kernel is missing inode->i_mutex nesting subclasses for the lock validator
+which is triggering implicit declaration error. To workaround this hardcore use of mutex_lock by removing
+kernel version check.
+---
+--- a/vfs.c
++++ b/vfs.c
+@@ -544,15 +544,9 @@ int cifsd_vfs_setattr(struct cifsd_work
+ 
+ 	attrs->ia_valid |= ATTR_CTIME;
+ 
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_lock(inode);
+-	err = notify_change(dentry, attrs, NULL);
+-	inode_unlock(inode);
+-#else
+ 	mutex_lock(&inode->i_mutex);
+ 	err = notify_change(dentry, attrs, NULL);
+ 	mutex_unlock(&inode->i_mutex);
+-#endif
+ 
+ 	if (update_size)
+ 		put_write_access(inode);
+@@ -753,11 +747,8 @@ int cifsd_vfs_remove_file(char *name)
+ 	if (!dir->d_inode)
+ 		goto out;
+ 
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_lock_nested(dir->d_inode, I_MUTEX_PARENT);
+-#else
+ 	mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+-#endif
++
+ 	dentry = lookup_one_len(last, dir, strlen(last));
+ 	if (IS_ERR(dentry)) {
+ 		err = PTR_ERR(dentry);
+@@ -783,11 +774,7 @@ int cifsd_vfs_remove_file(char *name)
+ 
+ 	dput(dentry);
+ out_err:
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_unlock(dir->d_inode);
+-#else
+ 	mutex_unlock(&dir->d_inode->i_mutex);
+-#endif
+ out:
+ 	path_put(&parent);
+ 	return err;
+@@ -1302,11 +1289,8 @@ int cifsd_vfs_unlink(struct dentry *dir,
+ 	int err = 0;
+ 
+ 	dget(dentry);
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_lock(dir->d_inode);
+-#else
+ 	mutex_lock(&dir->d_inode->i_mutex);
+-#endif
++
+ 	if (!dentry->d_inode || !dentry->d_inode->i_nlink) {
+ 		err = -ENOENT;
+ 		goto out;
+@@ -1318,11 +1302,8 @@ int cifsd_vfs_unlink(struct dentry *dir,
+ 		err = vfs_unlink(dir->d_inode, dentry, NULL);
+ 
+ out:
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_unlock(dir->d_inode);
+-#else
+ 	mutex_unlock(&dir->d_inode->i_mutex);
+-#endif
++
+ 	dput(dentry);
+ 	if (err)
+ 		cifsd_debug("failed to delete, err %d\n", err);

cifsd/Makefile

@@ -0,0 +1,60 @@
+include $(TOPDIR)/rules.mk
+include $(INCLUDE_DIR)/kernel.mk
+
+PKG_NAME:=cifsd
+PKG_RELEASE:=1
+
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_URL:=https://github.com/namjaejeon/cifsd.git
+PKG_SOURCE_DATE:=2019-03-05
+PKG_SOURCE_VERSION:=e1715ce125d55b125b1b58a6f1819ef8e54cc3ba
+PKG_MIRROR_HASH:=521585ebfda0ecc02372b1a38ebf762fbbcead6d0b754a47599a5bf6bfdb3fb6
+
+PKG_MAINTAINER:=Andy Walsh <andy.walsh44+github@gmail.com>
+PKG_LICENSE:=GPL-2.0
+PKG_LICENSE_FILES:=COPYING
+
+include $(INCLUDE_DIR)/package.mk
+
+define KernelPackage/fs-cifsd
+	SUBMENU:=Filesystems
+	TITLE:=CIFS/SMB kernel server support
+	FILES:=$(PKG_BUILD_DIR)/cifsd.$(LINUX_KMOD_SUFFIX)
+	DEPENDS+= \
+		+kmod-nls-base \
+		+kmod-nls-utf8 \
+		+kmod-crypto-md4 \
+		+kmod-crypto-md5 \
+		+kmod-crypto-hmac \
+		+kmod-crypto-ecb \
+		+kmod-crypto-des \
+		+kmod-crypto-sha256 \
+		+kmod-crypto-cmac \
+		+kmod-crypto-sha512 \
+		+kmod-crypto-aead \
+		+kmod-crypto-ccm
+	KCONFIG:= \
+		CONFIG_KEYS=y \
+		CONFIG_CRYPTO_ARC4=y
+endef
+
+define KernelPackage/fs-cifsd/description
+	Kernel module for a CIFS/SMBv2,3 fileserver.
+endef
+
+TARGET_CFLAGS+= -DCONFIG_CIFSD_ACL
+
+MAKE_OPTS:=\
+	ARCH="$(LINUX_KARCH)" \
+	CROSS_COMPILE="$(TARGET_CROSS)" \
+	M="$(PKG_BUILD_DIR)"
+
+define Build/Compile
+	$(MAKE) -C "$(LINUX_DIR)" \
+		$(MAKE_OPTS) \
+		CFLAGS="$(TARGET_CFLAGS)" \
+		CONFIG_CIFS_SERVER=m \
+		modules
+endef
+
+$(eval $(call KernelPackage,fs-cifsd))

cifsd/patches/001-fix_implicit_declarations.patch

@@ -0,0 +1,69 @@
+--- a/vfs.c
++++ b/vfs.c
+@@ -544,15 +544,9 @@ int cifsd_vfs_setattr(struct cifsd_work
+ 
+ 	attrs->ia_valid |= ATTR_CTIME;
+ 
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_lock(inode);
+-	err = notify_change(dentry, attrs, NULL);
+-	inode_unlock(inode);
+-#else
+ 	mutex_lock(&inode->i_mutex);
+ 	err = notify_change(dentry, attrs, NULL);
+ 	mutex_unlock(&inode->i_mutex);
+-#endif
+ 
+ 	if (update_size)
+ 		put_write_access(inode);
+@@ -753,11 +747,8 @@ int cifsd_vfs_remove_file(char *name)
+ 	if (!dir->d_inode)
+ 		goto out;
+ 
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_lock_nested(dir->d_inode, I_MUTEX_PARENT);
+-#else
+ 	mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
+-#endif
++
+ 	dentry = lookup_one_len(last, dir, strlen(last));
+ 	if (IS_ERR(dentry)) {
+ 		err = PTR_ERR(dentry);
+@@ -783,11 +774,7 @@ int cifsd_vfs_remove_file(char *name)
+ 
+ 	dput(dentry);
+ out_err:
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_unlock(dir->d_inode);
+-#else
+ 	mutex_unlock(&dir->d_inode->i_mutex);
+-#endif
+ out:
+ 	path_put(&parent);
+ 	return err;
+@@ -1302,11 +1289,8 @@ int cifsd_vfs_unlink(struct dentry *dir,
+ 	int err = 0;
+ 
+ 	dget(dentry);
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_lock(dir->d_inode);
+-#else
+ 	mutex_lock(&dir->d_inode->i_mutex);
+-#endif
++
+ 	if (!dentry->d_inode || !dentry->d_inode->i_nlink) {
+ 		err = -ENOENT;
+ 		goto out;
+@@ -1318,11 +1302,8 @@ int cifsd_vfs_unlink(struct dentry *dir,
+ 		err = vfs_unlink(dir->d_inode, dentry, NULL);
+ 
+ out:
+-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
+-	inode_unlock(dir->d_inode);
+-#else
+ 	mutex_unlock(&dir->d_inode->i_mutex);
+-#endif
++
+ 	dput(dentry);
+ 	if (err)
+ 		cifsd_debug("failed to delete, err %d\n", err);

crashlog/files/etc/init.d/crashlog

@@ -4,16 +4,15 @@ START=99
 
 send_log()
 {
-	nr=$(db get hw.board.serialNumber)
-	hw=$(db get hw.board.hardware)
-	hwv=$(db get hw.board.hardwareVersion)
-	bid=$(db get hw.board.boardId)
+	nr=$(db get hw.board.serial_number)
+	hw=$(db get hw.board.model_name)
+	fam=$(db get hw.board.iopVerFam)
 	sw=$(db get hw.board.iopVersion)
 	server=$(/sbin/uci get system.crashlog.server)
 
 	while true
 	do
-	    scp  -S /usr/sbin/logssh /proc/last_kmsg log@${server}:log/${bid}_${hwv}_${hw}_${sw}_${nr}
+	    scp  -S /usr/sbin/logssh /proc/last_kmsg log@${server}:log/${fam}_${hw}_${sw}_${nr}
 	    if [ $? == 0 ]
 	    then
 	       break;
@@ -28,7 +27,7 @@ fill_in_default()
     /sbin/uci add system log
     /sbin/uci rename system.@log[-1]=crashlog
     /sbin/uci set system.crashlog.enable=no
-    /sbin/uci set system.crashlog.server="crash.inteno.se"
+    /sbin/uci set system.crashlog.server="crashlog.iopsys.eu"
     /sbin/uci commit
 }
 

crashlog/files/sbin/logcore

@@ -20,7 +20,7 @@ fill_in_default()
     /sbin/uci add system log
     /sbin/uci rename system.@log[-1]=corelog
     /sbin/uci set system.corelog.enable=no
-    /sbin/uci set system.corelog.server="crash.inteno.se"
+    /sbin/uci set system.corelog.server="corelog.iopsys.eu"
     /sbin/uci commit
 }
 
@@ -50,12 +50,11 @@ cat >$TMP_CORE
 # more memory to work with. normally this would do nothing.
 cat >/dev/null
 
-nr=$(db get hw.board.serialNumber)
-hw=$(db get hw.board.hardware)
-hwv=$(db get hw.board.hardwareVersion)
-bid=$(db get hw.board.boardId)
+nr=$(db get hw.board.serial_number)
+hw=$(db get hw.board.model_name)
+fam=$(hw.board.iopVerFam)
 sw=$(db get hw.board.iopVersion)
 
-scp -S /usr/sbin/logssh $TMP_CORE log@${server}:log/core_${1}_${2}_${bid}_${hwv}_${hw}_${sw}_${nr}
+scp -S /usr/sbin/logssh $TMP_CORE log@${server}:log/core_${1}_${2}_${fam}_${hw}_${sw}_${nr}
 rm $TMP_CORE
 

dectmngr/Makefile

@@ -0,0 +1,68 @@
+#
+# Copyright (C) 2020 iopsys Software Solutions AB
+#
+# This is free software, licensed under the GNU General Public License v2.
+# See /LICENSE for more information.
+#
+include $(TOPDIR)/rules.mk
+
+PKG_NAME:=dectmngr
+PKG_RELEASE:=1
+PKG_VERSION:=1.0
+
+LOCAL_DEV=1
+ifneq ($(LOCAL_DEV),1)
+PKG_SOURCE_URL:=https://dev.iopsys.eu/iopsys/dectmngr.git
+PKG_SOURCE_PROTO:=git
+PKG_SOURCE_VERSION:=2c8990fd5275d469e8ab6c7a99e17fe0a56052ea
+endif
+
+PKG_LICENSE:=GPLv2
+PKG_LICENSE_FILES:=LICENSE
+
+RSTRIP:=true
+export BUILD_DIR
+
+PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_VERSION)
+
+PKG_SOURCE:=$(PKG_NAME)-$(PKG_VERSION)-$(PKG_SOURCE_VERSION).tar.gz
+PKG_BUILD_PARALLEL:=1
+
+include $(INCLUDE_DIR)/package.mk
+
+define Package/$(PKG_NAME)
+	CATEGORY:=Utilities
+ 	TITLE:=DECT Manager
+ 	DEPENDS:= +libubox +ubus +libpicoevent
+endef
+
+define Package/$(PKG_NAME)/description
+	DECT manager is a daemon that provides UBUS RPC objects and sends UBUS events for communication with the DECT chip.
+endef
+
+ifeq ($(LOCAL_DEV),1)
+define Build/Prepare
+	$(CP) -r src/* $(PKG_BUILD_DIR)/
+endef
+endif
+
+MAKE_FLAGS += \
+	CFLAGS+="-Wall"
+
+define Package/$(PKG_NAME)/install
+	$(INSTALL_DIR) $(1)/usr/sbin
+	$(INSTALL_DIR) $(1)/usr/lib
+	$(INSTALL_DIR) $(1)/etc/dect/
+	$(INSTALL_DIR) $(1)/etc/config/
+	$(INSTALL_DIR) $(1)/etc/init.d/
+
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/test/testout/dectmngr $(1)/usr/sbin/
+	$(STRIP) $(1)/usr/sbin/dectmngr
+	$(INSTALL_BIN) $(PKG_BUILD_DIR)/test/testout/libdect.so $(1)/usr/lib/
+	$(STRIP) $(1)/usr/lib/libdect.so
+	#$(INSTALL_BIN) $(PKG_BUILD_DIR)/files/target.bin $(1)/etc/dect/
+	#$(INSTALL_BIN) $(PKG_BUILD_DIR)/files/dect $(1)/etc/init.d/
+	#$(CP) ./files/dect.config $(1)/etc/config/dect
+endef
+
+$(eval $(call BuildPackage,$(PKG_NAME)))

dectmngr/files/DCX81_fw_c/MOD/USB/DCX81_MOD_USB.md5

@@ -0,0 +1,4 @@
+9c5962fc5bdef309d15cf76dd2678297  out4/Images/PRODUCT_IOPSYS/DCX81_fw_c/MOD/USB/DCX81_MOD_USB.ITCM
+17d4a7e4021c6089104c28c228245df2  out4/Images/PRODUCT_IOPSYS/DCX81_fw_c/MOD/USB/DCX81_MOD_USB.ITCM_L
+d32e2a3dd05f4d1933eac77cfff091ba  out4/Images/PRODUCT_IOPSYS/DCX81_fw_c/MOD/USB/DCX81_MOD_USB.bin
+477bfa4e91914db4c0078b31a6cdf208  out4/Images/PRODUCT_IOPSYS/DCX81_fw_c/MOD/USB/DCX81_MOD_USB.BOOTLOADER.bin

dectmngr/files/DCX81_fw_c/MOD/USB/DCX81_MOD_USB_EEPROM_MD5_SIG.md5

@@ -0,0 +1 @@
+{0xee,0xb7,0x3c,0x8f,0x44,0xe1,0xad,0x87,0x53,0xc8,0x57,0x4e,0x08,0x6d,0x87,0x9f}

dectmngr/files/DCX81_fw_c/MOD/USB/DCX81_MOD_USB_EEPROM_Map.htm

@@ -0,0 +1,984 @@
+
+<html>
+
+	<head>
+
+		<title>EEPROM map </title>
+
+		<style>
+
+			<!--
+
+				th {
+
+					font-size: 12px;
+
+					font-family: Verdana, Arial, Helvetica, sans-serif;
+
+					font-style: bold;
+
+				}
+
+				td {
+
+					font-size: 10px;
+
+					font-family: Verdana, Arial, Helvetica, sans-serif;
+
+				}
+
+				body {
+
+					background-color: #FFFFFF;
+
+				}
+
+			-->
+
+			
+
+		</style>
+
+	</head>
+
+	<body>
+
+		<h1>EEPROM map bsd02eep.h-GIT</h1>
+
+
+<table border="2" cellspacing="2" width="100%" rules="both" align="center" style=" font-size: 10px;
+					font-family: Verdana, Arial, Helvetica, sans-serif;
+					background-color: #C9FFDA;
+					border-collapse: collapse;
+					border: 5px solid white">
+<tbody>
+<tr style=" font-size: 12px;
+					font-family: Verdana, Arial, Helvetica, sans-serif;
+					font-style: bold;
+					background-color: #78FF95"><td>Name</td><td align="center">Offset</td><td>Comment</td><td width="100">Default</td></tr>
+<tr><td>SD02_RESERVED1[4]</td><td align="center">0(0x0)</td><td> L4   RESERVED1 </td><td width="100"></td></tr>
+<tr><td>SD02_RESERVED2[5]</td><td align="center">4(0x4)</td><td> L5  RESERVED2 </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_GFSK[10]</td><td align="center">9(0x9)</td><td> L10 </td><td width="100">0x80,0x80,0x80,0x80,0x80,
+
+0x80,0x80,0x80,0x80,0x80,
+</td></tr>
+<tr><td>SD02_PREAM_NORMAL</td><td align="center">19(0x13)</td><td> L1  </td><td width="100">0x65,
+</td></tr>
+<tr><td>SD02_TEST_FLAGS</td><td align="center">20(0x14)</td><td> L1           If set: 																bit 0: BMP Driver Recover disabled 
+																bit 1: Watchdog not enabled
+																bit 3: disable activity led </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_EMC_MODEL[3]</td><td align="center">21(0x15)</td><td> L3   EMC number and model, transfered in MODEL_ID IE </td><td width="100">0x0F,0xEB,0x02,
+</td></tr>
+<tr><td>SD02_RVREF</td><td align="center">24(0x18)</td><td> L1  </td><td width="100">0x1F,
+</td></tr>
+<tr><td>SD02_TEST_MODE</td><td align="center">25(0x19)</td><td> L1  Enter TBR6/10 </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_RXTUN</td><td align="center">26(0x1A)</td><td> L1  FR            </td><td width="100">0x70,
+</td></tr>
+<tr><td>SD02_AUXBGPROG</td><td align="center">27(0x1B)</td><td> L1  AUXBGPROG (Bandgap calibration value)  </td><td width="100">0x66,
+</td></tr>
+<tr><td>SD02_RVDDC</td><td align="center">28(0x1C)</td><td> L1  </td><td width="100">0x97,
+</td></tr>
+<tr><td>SD02_POWER_CONTROL</td><td align="center">29(0x1D)</td><td> L1  Power Control: nibble usage (0xsw) where															s is ARM clock speed and w the number of
+															pflash waitstates.
+															Note: For ICELP, the default ARM clock
+															speed is 64 (96MHz and 4 wait states).
+															Note: For VegaOne s is used as an index to
+															recommended clock settings (see
+															VegaOne_AHB_PLLDIV[16] in file
+															cdr17tim.c).
+															For VegaOne: bit 3 is used to select if flash
+															running in syncrounous (asyncronous = 0
+															syncronous = 1)</td><td width="100">0x2,
+</td></tr>
+<tr><td>SD02_WDCT_HOP_CONTROL</td><td align="center">30(0x1E)</td><td> L1  </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_WDCT_QUAL_CONTROL</td><td align="center">31(0x1F)</td><td> L1  WDCT Quality Control:																When the most significant bit of this byte is
+																set to 1, the hop sequence of 19 and frequency
+																substitution can be disabled.</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_US_DECT</td><td align="center">32(0x20)</td><td> L1  </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_MAX_USABLE_RSSI</td><td align="center">33(0x21)</td><td> L1  </td><td width="100">0x78,
+</td></tr>
+<tr><td>SD02_LOWER_RSSI_LIMIT</td><td align="center">34(0x22)</td><td> L1  </td><td width="100">0x50,
+</td></tr>
+<tr><td>SD02_V22_VOL_HIGH</td><td align="center">35(0x23)</td><td> L1   V22 Volume Low - Sidetone  </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_V22_VOL_LOW</td><td align="center">36(0x24)</td><td> L1   V22 Volume High - Sidetone   </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_DSP_CID_THRES</td><td align="center">37(0x25)</td><td> L1   CID Threshold</td><td width="100">0x51,
+</td></tr>
+<tr><td>SD02_DSP_PATCH[50]</td><td align="center">38(0x26)</td><td> L50 DSP patch area														8 entries, each defines a flexible value for 1
+														DSP parameter.
+														Structure:
+														1st Word: DSP instance (low, high byte)
+														2nd Word: offset (low, high byte)
+														3rd Word: value (low, high byte)</td><td width="100">0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_ARM_PATCH[40]</td><td align="center">88(0x58)</td><td> L40: 0=unused    ARM patch area (5 entries):															5 X 2 X4 Bytes to modify any 30 bit ARM
+															address location after protocol stack initialisation:
+															1st Word: address (big endian)
+															2nd Word: value (big endian)
+															The 2 MSBits of the address define the
+															write access type:
+															00: Word access (u32)
+															01: Halfword access (u16)
+															10: Byte access (u8) </td><td width="100">0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_DSP_CLOCK</td><td align="center">128(0x80)</td><td> L1  </td><td width="100">0x02,
+</td></tr>
+<tr><td>SD02_FWROM_BOARDER</td><td align="center">129(0x81)</td><td> L1  </td><td width="100">0x1D,
+</td></tr>
+<tr><td>SD02_PORBGCFG</td><td align="center">130(0x82)</td><td> L1  PORBGCFG (POR calibration value) </td><td width="100">0xC0,
+</td></tr>
+<tr><td>SD02_FPTR</td><td align="center">131(0x83)</td><td> L1 MSB used to enable/disable                                                            use of this parameter 0=enable </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_FULL_POWER</td><td align="center">132(0x84)</td><td> DTPC Full Power </td><td width="100">0x7F,
+</td></tr>
+<tr><td>SD02_LOW_POWER</td><td align="center">133(0x85)</td><td> DTPC Low(medium) Power </td><td width="100">0xC4,
+</td></tr>
+<tr><td>SD02_LOWEST_POWER</td><td align="center">134(0x86)</td><td> DTPC Lowest Power</td><td width="100">0x03,
+</td></tr>
+<tr><td>SD02_AEC_LSP_ATTEN_RANGE[2]</td><td align="center">135(0x87)</td><td> L2   AEC_lsp_atten_range																For all AEC parameters see User Manual
+																Vega-Family ARM DSP RELEASE V7.5
+																(or higher)</td><td width="100">0x00, 0x08,
+</td></tr>
+<tr><td>SD02_AEC_NLMS_ERL[2]</td><td align="center">137(0x89)</td><td> L2   </td><td width="100">0x40, 0x00,
+</td></tr>
+<tr><td>SD02_AEC_X_CLIP[2]</td><td align="center">139(0x8B)</td><td> L2   </td><td width="100">0x0F, 0x1F,
+</td></tr>
+<tr><td>SD02_AEC_ECHO_RATIO[2]</td><td align="center">141(0x8D)</td><td> L2   </td><td width="100">0x00, 0x01,
+</td></tr>
+<tr><td>SD02_AEC_DENS_GAMMA_E_HIGH[2]</td><td align="center">143(0x8F)</td><td> L2   </td><td width="100">0xCC, 0x01,
+</td></tr>
+<tr><td>SD02_AEC_DENS_GAMMA_E_LOW[2]</td><td align="center">145(0x91)</td><td> L2   </td><td width="100">0x80, 0x00,
+</td></tr>
+<tr><td>SD02_AEC_DENS_GAMMA_E_DT[2]</td><td align="center">147(0x93)</td><td> L2   </td><td width="100">0x66, 0x01,
+</td></tr>
+<tr><td>SD02_AEC_DENS_GAMMA_N[2]</td><td align="center">149(0x95)</td><td> L2   </td><td width="100">0x00, 0x01,
+</td></tr>
+<tr><td>SD02_AEC_DENS_TAIL_ALPHA[2]</td><td align="center">151(0x97)</td><td> L2   </td><td width="100">0x66, 0x66,
+</td></tr>
+<tr><td>SD02_AEC_DENS_TAIL_PORTION[2]</td><td align="center">153(0x99)</td><td> L2   </td><td width="100">0xD7, 0x03,
+</td></tr>
+<tr><td>SD02_AEC_DENS_NL_ATTEN[2]</td><td align="center">155(0x9B)</td><td> L2   </td><td width="100">0x00, 0x08,
+</td></tr>
+<tr><td>SD02_AEC_DENS_CNI_LEVEL[2]</td><td align="center">157(0x9D)</td><td> L2   </td><td width="100">0x00, 0x20,
+</td></tr>
+<tr><td>SD02_AEC_MODE[2]</td><td align="center">159(0x9F)</td><td> L2   </td><td width="100">0xF7, 0x00,
+</td></tr>
+<tr><td>SD02_AEC_ECHO_PATH_DELAY[2]</td><td align="center">161(0xA1)</td><td> L2   </td><td width="100">0x00, 0x00,
+</td></tr>
+<tr><td>SD02_DTPC_ENABLE</td><td align="center">163(0xA3)</td><td></td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_RSSI_TIMER</td><td align="center">164(0xA4)</td><td></td><td width="100">0x64,
+</td></tr>
+<tr><td>SD02_DRPC_RSSI_THRESH</td><td align="center">165(0xA5)</td><td></td><td width="100">0x80,
+</td></tr>
+<tr><td>SD02_DRPC_RSSI_CORRECT</td><td align="center">166(0xA6)</td><td></td><td width="100">0x1C,
+</td></tr>
+<tr><td>SD02_RVR2C_INIT</td><td align="center">167(0xA7)</td><td> L1 </td><td width="100">0x40,
+</td></tr>
+<tr><td>SD02_FI_TRIG_GPIO</td><td align="center">168(0xA8)</td><td> L1 </td><td width="100">0x0,
+</td></tr>
+<tr><td>SD02_RF19APU_SUPPORT_FCC</td><td align="center">169(0xA9)</td><td> L1 </td><td width="100">0x0,
+</td></tr>
+<tr><td>SD02_RF19APU_TC_DELAY</td><td align="center">170(0xAA)</td><td> L1 </td><td width="100">0x3,
+</td></tr>
+<tr><td>SD02_RF19APU_GAP_DELAY</td><td align="center">171(0xAB)</td><td> L1 </td><td width="100">0x8,
+</td></tr>
+<tr><td>SD02_RF19APU_GAP_DELAY_FADOFF</td><td align="center">172(0xAC)</td><td> L1 </td><td width="100">0xA,
+</td></tr>
+<tr><td>SD02_RF19APU_TRSSI_DELAY</td><td align="center">173(0xAD)</td><td> L1 </td><td width="100">0x25,
+</td></tr>
+<tr><td>SD02_RF19APU_TRSSI_DELAY_FADOFF</td><td align="center">174(0xAE)</td><td> L1 </td><td width="100">0x13,
+</td></tr>
+<tr><td>SD02_RF19APU_DEVIATION</td><td align="center">175(0xAF)</td><td> L1 </td><td width="100">0x13,
+</td></tr>
+<tr><td>SD02_RF19APU_ATEST</td><td align="center">176(0xB0)</td><td> L1 </td><td width="100">0xF,
+</td></tr>
+<tr><td>SD02_RF19APU_DTEST</td><td align="center">177(0xB1)</td><td> L1 </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_RF19APU_PA2_COMP</td><td align="center">178(0xB2)</td><td> L1 </td><td width="100">0x3C,
+</td></tr>
+<tr><td>SD02_RF19APU_PA_ON</td><td align="center">179(0xB3)</td><td> L1 </td><td width="100">0x33,
+</td></tr>
+<tr><td>SD02_RF19APU_GAIN</td><td align="center">180(0xB4)</td><td> L1 </td><td width="100">0x0,
+</td></tr>
+<tr><td>SD02_RF19APU_MLSE</td><td align="center">181(0xB5)</td><td>L1 Bit        Meaning											 	             0         MLSE active
+											 		     1         Dynamic MLSE active
+											 		     2         MLSE CLK Polarity
+													     3         MLSE deviation 0 <20> 288, 1 <20> 360
+													     4         4 bit field giving MLSE delay in bits
+													     5         If set to 0 <20> delay defaults to 9
+													     6                     <20>
+													     7                     <20>
+																			</td><td width="100">0x1,
+</td></tr>
+<tr><td>SD02_RF19APU_KCALOVR</td><td align="center">182(0xB6)</td><td>L1 </td><td width="100">0x0,
+</td></tr>
+<tr><td>SD02_RF19APU_KCALOVR_LINEAR</td><td align="center">183(0xB7)</td><td>L1 Linear KCAL correction, 4 LSB A factor (KCALOVR_A) 4 MSB B factor  (KCALOVR_B)</td><td width="100">0x88,
+</td></tr>
+<tr><td>SD02_RF19APU_BEACON_LP</td><td align="center">184(0xB8)</td><td>L1 Bit0 - Enable. Bit1-7 - Value of power when HS on cradle</td><td width="100">0xC1,
+</td></tr>
+<tr><td>SD02_RF19APU_GENERIC_ADD1[2]</td><td align="center">185(0xB9)</td><td> L2 </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_RF19APU_GENERIC_ADD2[2]</td><td align="center">187(0xBB)</td><td> L2 </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_RF19APU_GENERIC_ADD3[2]</td><td align="center">189(0xBD)</td><td> L2 </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_RF19APU_GENERIC_ADD4[2]</td><td align="center">191(0xBF)</td><td> L2 </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_RF19APU_GENERIC_CONTROL</td><td align="center">193(0xC1)</td><td>L1 																	bit [1:0] = control of SD02_RF19APU_GENERIC_ADD1
+																	bit [3:2] = control of SD02_RF19APU_GENERIC_ADD2
+																	bit [5:4] = control of 
+																	SD02_RF19APU_GENERIC_ADD3
+																	bit [7:6] = control of SD02_RF19APU_GENERIC_ADD4
+
+																	for each of the above: 
+																	if 0 (or 3): use the appropriate register as RF indirect mapping 0~256
+																	if 1: use the appropriate register as direct space mapping 0 <20> 104
+																	if 2: use the appropriate register as analog indirect space mapping 0 <20> 69
+																</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_FNR_N_LOW[2]</td><td align="center">194(0xC2)</td><td> L2 FNR SD02_FNR_N_LOW </td><td width="100">0x00,0x01,
+</td></tr>
+<tr><td>SD02_FNR_N_HIGH[2]</td><td align="center">196(0xC4)</td><td> L2 FNR SD02_FNR_N_HIGH </td><td width="100">0x40,0x01,
+</td></tr>
+<tr><td>SD02_FNR_NR_LIMIT[2]</td><td align="center">198(0xC6)</td><td> L2 FNR SD02_FNR_NR_LIMIT </td><td width="100">0x00,0x28,
+</td></tr>
+<tr><td>SD02_FNR_spDETCC[2]</td><td align="center">200(0xC8)</td><td> L2 FNR SD02_FNR_spDETCC </td><td width="100">0x00,0x02,
+</td></tr>
+<tr><td>SD02_FNR_Ton_detect[2]</td><td align="center">202(0xCA)</td><td> L2 FNR SD02_FNR_Ton_detect </td><td width="100">0x00,0x06,
+</td></tr>
+<tr><td>SD02_CR_OPTIONS</td><td align="center">204(0xCC)</td><td> L1 -															Bit 0-1: Codec preferred (0-G726,1-G727,other reserved)
+															Bit 2: Action in Normal - unused
+															Bit 3: Action in Protected - unused
+															Bit 4: Opt G726 - activate improved - unused
+															Bit 5-6: Mode (0-Auto,1-Normal,2-Protected,3-Reserved) - not relevant in FT
+															Bit 7: Enable/Disable.
+														</td><td width="100">0x81,
+</td></tr>
+<tr><td>SD02_CR_SB_PATT</td><td align="center">205(0xCD)</td><td>L1 - Padding option for SB (i.e. nibble) either 4 bits or 8 bitsfor WB codecs </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_CR_FB_PATT</td><td align="center">206(0xCE)</td><td>L1 - Padding option for FB (i.e. all frame) either 4 bits or 8 bits for WB codecs </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_CR_START_MUTE_NR</td><td align="center">207(0xCF)</td><td>L1 - Number of errors to start full frame mute	   </td><td width="100">0x1E,
+</td></tr>
+<tr><td>SD02_CR_STOP_MUTE_NR</td><td align="center">208(0xD0)</td><td>L1 - Number of errors to stop full frame mute	   </td><td width="100">0x0F,
+</td></tr>
+<tr><td>SD02_CR_DECAY[2]</td><td align="center">209(0xD1)</td><td>L2 - First Byte - Decay MSB, Second byte : Decay LSB (in Q12) </td><td width="100">0x0F,
+
+0xD4,
+</td></tr>
+<tr><td>SD02_CR_SATURATION</td><td align="center">211(0xD3)</td><td>L1 - Saturation value for FB filter </td><td width="100">0x28,
+</td></tr>
+<tr><td>SD02_CR_MSG</td><td align="center">212(0xD4)</td><td>L1 - Nr of Frames before msg mute/unmute </td><td width="100">0x1E,
+</td></tr>
+<tr><td>SD02_CONTROL</td><td align="center">213(0xD5)</td><td>L1 - Enable Clock Divider Selection</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_CLK_DIV[3]</td><td align="center">214(0xD6)</td><td>L3 - Clock Divider Setting </td><td width="100">0x00,0x00,0x00,
+</td></tr>
+<tr><td>SD02_CLK_SEL[2]</td><td align="center">217(0xD9)</td><td>L2 - Clock Selection </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_AHB_PLL_SETTING_LOW[4]</td><td align="center">219(0xDB)</td><td>L4 - AHB PLL LOW Setting </td><td width="100">0x00,0x00,0x00,0x00,
+</td></tr>
+<tr><td>SD02_AHB_PLL_SETTING_MED[4]</td><td align="center">223(0xDF)</td><td>L4 - AHB PLL MED Setting </td><td width="100">0x00,0x00,0x00,0x00,
+</td></tr>
+<tr><td>SD02_AHB_PLL_SETTING_HIGH[4]</td><td align="center">227(0xE3)</td><td>L4 - AHB PLL HIGH Setting </td><td width="100">0x00,0x00,0x00,0x00,
+</td></tr>
+<tr><td>SD02_CP_FEATURES</td><td align="center">231(0xE7)</td><td>L1 - CP features  Setting </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_CP_CONFIGURATION_OFFSET</td><td align="center">232(0xE8)</td><td>Bit 0: If set, SYPO alignment is offset by 1 slot,Bit 2: Dummy Merge to first traffic</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_CP_ULE_FLAGS</td><td align="center">233(0xE9)</td><td> L1 - Phase 1: 0x2, Phase 1.2: 0x6 ,Phase 2: 0xA, Phase 3: 0xE</td><td width="100">0x0A,
+</td></tr>
+<tr><td>SD02_DUMMY_BEARER_THRES_ADAPT_THRESH</td><td align="center">234(0xEA)</td><td></td><td width="100">0x58,
+</td></tr>
+<tr><td>SD02_RF19APUZ_EXT_LNA</td><td align="center">235(0xEB)</td><td>L1 - CP features  Setting </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_RFIC_SELECTION</td><td align="center">236(0xEC)</td><td>L1 - CP features  Setting </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_UNUSED_210</td><td align="center">237(0xED)</td><td> L1    </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_PHS_SCAN_PARAM</td><td align="center">238(0xEE)</td><td> JDECT parameters: RSSI threshold for PHS detection. PHS scan every 10 seconds. </td><td width="100">0x0C,
+</td></tr>
+<tr><td>SD02_JDECT_LEVEL1_M82</td><td align="center">239(0xEF)</td><td> minus 82 dBm RSSI threshold for Japan regulation </td><td width="100">0x0B,
+</td></tr>
+<tr><td>SD02_JDECT_LEVEL2_M62</td><td align="center">240(0xF0)</td><td> minus 62 dBm RSSI threshold for Japan regulation </td><td width="100">0x11,
+</td></tr>
+<tr><td>SD02_JDECT_CERTAINTY_PARAM</td><td align="center">241(0xF1)</td><td> PHS detection Certainty parameters.(upper nibble reduces miss detection. lower nibble reduces false alaram) </td><td width="100">0x55,
+</td></tr>
+<tr><td>SD02_ULE_DUMMY_TRAF_THRESH</td><td align="center">242(0xF2)</td><td>L1 - Threshold for dummy traffic bearer merge</td><td width="100">0x03,
+</td></tr>
+<tr><td>SD02_PWR_ADC_INPUT</td><td align="center">243(0xF3)</td><td> L1 Input source of the Auxiliary A/D  	  </td><td width="100">0x0E,
+</td></tr>
+<tr><td>SD02_PWR_POR_INPUT</td><td align="center">244(0xF4)</td><td> L1 Input source of the POR A/D			  </td><td width="100">0x16,
+</td></tr>
+<tr><td>SD02_RES_FACTOR</td><td align="center">245(0xF5)</td><td> L1 Resistor Factor on AUX input 		  </td><td width="100">0x02,
+</td></tr>
+<tr><td>SD02_UART_DELAY_TIMER</td><td align="center">246(0xF6)</td><td>L1 - Selects the timer in 10 msec to delay UART</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_V21_VOL_HIGH</td><td align="center">247(0xF7)</td><td>L2 SD02_V21_VOL_HIGH </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_V21_VOL_LOW</td><td align="center">248(0xF8)</td><td>L2 SD02_V21_VOL_LOW </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_PRODUCTION_TEST_RSSI_THRESH_DOWNLINK</td><td align="center">249(0xF9)</td><td>L1 SD02_PRODUCTION_TEST_RSSI_THRESH_DOWNLINK </td><td width="100">0x88,
+</td></tr>
+<tr><td>SD02_PRODUCTION_TEST_RSSI_THRESH_UPLINK</td><td align="center">250(0xFA)</td><td>L1 SD02_PRODUCTION_TEST_RSSI_THRESH_UPLINK </td><td width="100">0x88,
+</td></tr>
+<tr><td>SD02_FIXED_CARRIER_OFFSET</td><td align="center">251(0xFB)</td><td>L1 SD02_FIXED_CARRIER_OFFSET -  																						Bit(0..5)  : Carrier to use , 
+																						Bit(6) : Enable fixed PM carrier , 
+																						Bit(7) :  Seta fixed carrier [bit(0..4)]  in RF file. When using this option you MUST set PP+FP with the same carrier.
+																						</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_TEMP_MEASURE_TIME</td><td align="center">252(0xFC)</td><td>L1 SD02_TEMP_MEASURE_TIME. 																								    bit 0-1 temperature measurement period for VCAL. 2 bits for 4 values 0,1,2,3 ==  5,1,2,3 minutes.   default value == 0  
+																								    </td><td width="100">0x00,
+</td></tr>
+<tr><td>FNCA_DRV_UNUSED</td><td align="center">253(0xFD)</td><td>  <----------- unused </td><td width="100">0xCC,</td></tr>
+<tr><td>SD02_SMS_FW_VERSION[6]</td><td align="center">253(0xFD)</td><td> L6  </td><td width="100">0xCC,0x21,0x10,0x20,0x03,0xCC,
+</td></tr>
+<tr><td>SD02_SMS_SMTE_RESOURCES</td><td align="center">259(0x103)</td><td> L1  </td><td width="100">0x11,
+</td></tr>
+<tr><td>SD02_SMS_BREAK_SMS_CALL</td><td align="center">260(0x104)</td><td> L1  </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_SMS_SUBADDR_MASK[2]</td><td align="center">261(0x105)</td><td> L2  </td><td width="100">0x00,0x03,
+</td></tr>
+<tr><td>SD02_SMS_MIN_BYTES_FREE</td><td align="center">263(0x107)</td><td> L1  </td><td width="100">0x28,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_OFFHOOK</td><td align="center">264(0x108)</td><td> L1  </td><td width="100">0x14,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_ESTABLISH</td><td align="center">265(0x109)</td><td> L1  </td><td width="100">0x14,
+</td></tr>
+<tr><td>SD02_SMS_HACK_CODE</td><td align="center">266(0x10A)</td><td> L1  </td><td width="100">0x10,
+</td></tr>
+<tr><td>SD02_SMS_TIMER_T2[2]</td><td align="center">267(0x10B)</td><td> L2  </td><td width="100">0x02,0xF8,
+</td></tr>
+<tr><td>SD02_SMS_TIMER_T3[2]</td><td align="center">269(0x10D)</td><td> L2  </td><td width="100">0x02,0xEE,
+</td></tr>
+<tr><td>SD02_SMS_TIMER_T6[2]</td><td align="center">271(0x10F)</td><td> L2  </td><td width="100">0x00,0x14,
+</td></tr>
+<tr><td>SD02_SMS_TIMER_T10</td><td align="center">273(0x111)</td><td> L1  </td><td width="100">0x0A,
+</td></tr>
+<tr><td>SD02_SMS_TIMER_T10BIS</td><td align="center">274(0x112)</td><td> L1  </td><td width="100">0x35,
+</td></tr>
+<tr><td>SD02_SMS_FSK_FREQ0[2]</td><td align="center">275(0x113)</td><td> L2  </td><td width="100">0x00,0x15,
+</td></tr>
+<tr><td>SD02_SMS_FSK_FREQ1[2]</td><td align="center">277(0x115)</td><td> L2  </td><td width="100">0x00,0x0D,
+</td></tr>
+<tr><td>SD02_SMS_FSK_CIT_VOL[2]</td><td align="center">279(0x117)</td><td> L2  </td><td width="100">0x13,0x00,
+</td></tr>
+<tr><td>SD02_SMS_FSK_TIMER_PREAM</td><td align="center">281(0x119)</td><td> L1  </td><td width="100">0x0D,
+</td></tr>
+<tr><td>SD02_SMS_PROT_RESP_TYPE</td><td align="center">282(0x11A)</td><td> L1  </td><td width="100">0x80,
+</td></tr>
+<tr><td>SD02_SMS_PROT_BEARER_CAP[20]</td><td align="center">283(0x11B)</td><td> L20 </td><td width="100">0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_SMS_PROT(k)[42]</td><td align="center">303(0x12F)</td><td>   21 * Nr_of_Protocols. Where 21 is the length of protocol. </td><td width="100">0x80,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0x80,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_SETTINGS</td><td align="center">345(0x159)</td><td> L1   </td><td width="100">0x12,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_VALIDITY_TIME</td><td align="center">346(0x15A)</td><td> L1   </td><td width="100">0x03,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_EMAIL_SEP</td><td align="center">347(0x15B)</td><td> L1    Email Separator</td><td width="100">0x20,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_OPERATOR</td><td align="center">348(0x15C)</td><td> L1   </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_UNUSED[2]</td><td align="center">349(0x15D)</td><td> L2    </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_INC_NUM[8]</td><td align="center">351(0x15F)</td><td> L8   </td><td width="100">0x04,0x21,0x1F,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_OUT_NUM[8]</td><td align="center">359(0x167)</td><td> L8   </td><td width="100">0x42,0x11,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_SMS_SMSC_EMAIL_NUM[8]</td><td align="center">367(0x16F)</td><td> L8   </td><td width="100">0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_SMS_SMSC(i)[90]</td><td align="center">375(0x177)</td><td>  SMSC area end SMSC * 30. Where 30 is the length of data for one SMSC </td><td width="100">0x01,
+
+0x03,
+
+0x20,
+
+0x00,
+
+0x00,0x00,
+
+0x01,0x93,0x01,0x0F,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0x01,0x93,0x01,0x0F,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0x08,0x00,0xF0,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0x01,
+
+0x03,
+
+0x20,
+
+0x00,
+
+0x00,0x00,
+
+0x20,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0x20,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0x01,
+
+0x03,
+
+0x20,
+
+0x05,
+
+0x00,0x00,
+
+0x01,0x90,0x01,0x50,
+
+0x4F,0xFF,0xFF,0xFF,
+
+0x01,0x90,0x01,0x50,
+
+0x4F,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+
+0xFF,0xFF,0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_ACV10_VOLUME[2]</td><td align="center">465(0x1D1)</td><td> L2   ACV10  Volume Control for SPK 2 bytes </td><td width="100">0x08,0x00,
+</td></tr>
+<tr><td>FNCA_SMS_UNUSED[2]</td><td align="center">467(0x1D3)</td><td>  <----------- unused </td><td width="100"></td></tr>
+<tr><td>SD02_CALL_BARRING[30]</td><td align="center">469(0x1D5)</td><td> L30  call barring data </td><td width="100"></td></tr>
+<tr><td>SD02_MASTER_PIN[4]</td><td align="center">499(0x1F3)</td><td> L4   master mode pin code, reset value e.g. FF FF 15 90 </td><td width="100">0xFF,0xFF,0x15,0x90,
+</td></tr>
+<tr><td>SD02_AC[4]</td><td align="center">503(0x1F7)</td><td> L4   authentication code, e.g. FF FF 15 90</td><td width="100">0xFF,0xFF,0x00,0x00,
+</td></tr>
+<tr><td>SD02_RING_ON_OFF</td><td align="center">507(0x1FB)</td><td> L1   ring on/off enabled </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_ULE_AC[4]</td><td align="center">508(0x1FC)</td><td> L4   ULE authentication code, e.g. FF FF 00 00</td><td width="100">0xFF,0xFF,0x00,0x00,
+</td></tr>
+<tr><td>SD02_EEPROM0_END</td><td align="center">512(0x200)</td><td></td><td width="100"></td></tr>
+<tr><td>SD02_BOOT_DELAY</td><td align="center">513(0x201)</td><td> L1  Boot up delay in seconds </td><td width="100"></td></tr>
+<tr><td>SD02_HAN_START_FILE_0[8514]</td><td align="center">514(0x202)</td><td><a href="bhanEepromDefaults.html">HAN EEPROM Block</a> </td><td width="100"></td></tr>
+<tr><td>SD02_HAN_END_FILE_0</td><td align="center">9028(0x2344)</td><td>   HAN EEPROM Block End</td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_IPUI[5]</td><td align="center">9029(0x2345)</td><td> L5   Data: IPUI </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_TPUI[3]</td><td align="center">9034(0x234A)</td><td> L3   Data: TPUI </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_DCK[16]</td><td align="center">9037(0x234D)</td><td> L16  Data: DCK </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_UAK[16]</td><td align="center">9053(0x235D)</td><td> L16  Data: UAK </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_AC[4]</td><td align="center">9069(0x236D)</td><td> L4   Data: authentication code AC </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_UAK_AUTH</td><td align="center">9073(0x2371)</td><td> L1   Data: UAK authorization </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_STATUS</td><td align="center">9074(0x2372)</td><td> L1   Data: status </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_HANDSET_NR</td><td align="center">9075(0x2373)</td><td> L1   Data: handset number </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_DCK_ASSIGNED[2]</td><td align="center">9076(0x2374)</td><td> L1   Data: DCK assigned </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_FEATURES</td><td align="center">9078(0x2376)</td><td> L1   CP Features </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_DEFCK[16]</td><td align="center">9079(0x2377)</td><td> L16  Data: Default Cipher Key </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_DEFCK_ASSIGNED</td><td align="center">9095(0x2387)</td><td> L1   Data: DefCK assigned </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_CCM_CK[16]</td><td align="center">9096(0x2388)</td><td> L16  Data: CCM Key for ULE </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_DLC_OPERATING_MODE</td><td align="center">9112(0x2398)</td><td> L1   ULE DLC operating mode </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_HL_FEATURES</td><td align="center">9113(0x2399)</td><td> L1   ULE HL features  </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_RESERVED[4]</td><td align="center">9114(0x239A)</td><td> L4   Reserved for future use </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_NEXT_RX_SEQUENCE_NUMBER[3]</td><td align="center">9118(0x239E)</td><td> L3   RX Sequence number </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_NEXT_TX_SEQUENCE_NUMBER[3]</td><td align="center">9121(0x23A1)</td><td> L3   TX Sequence number </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_OVER_A_FIELD_NEXT_RX_SEQUENCE_NUMBER[3]</td><td align="center">9124(0x23A4)</td><td> L3   RX Sequence number </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_OVER_A_FIELD_NEXT_TX_SEQUENCE_NUMBER</td><td align="center">9127(0x23A7)</td><td> L3   TX Sequence number </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_LEN[13978]</td><td align="center">101(0x65)</td><td>   End of first subscribtion </td><td width="100"></td></tr>
+<tr><td>SD02_ULE_SUB_UNUSED[5]</td><td align="center">14079(0x36FF)</td><td>  <----------- unused </td><td width="100"></td></tr>
+<tr><td>SD02_MD5_SIGNATURE[16]</td><td align="center">14084(0x3704)</td><td> L16 16 bytes of MD5 signature</td><td width="100"></td></tr>
+<tr><td>SD02_MD5_END</td><td align="center">14100(0x3714)</td><td> L0</td><td width="100"></td></tr>
+<tr><td>SD02_MD5_UNUSED</td><td align="center">14093(0x370D)</td><td>  <----------- unused </td><td width="100"></td></tr>
+<tr><td>FNCA_MMI_UNUSED[7]</td><td align="center">14093(0x370D)</td><td>  <----------- unused </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_LAL</td><td align="center">14100(0x3714)</td><td> L1  </td><td width="100">0x24,
+</td></tr>
+<tr><td>SD02_SUB_Y</td><td align="center">14101(0x3715)</td><td> L1  </td><td width="100">0x24,
+</td></tr>
+<tr><td>SD02_DSP_CID_MARK_MODE</td><td align="center">14102(0x3716)</td><td> L1  DSP   CID start state for mark mode - upper byte (Bits 8-15)   </td><td width="100">0x40,
+</td></tr>
+<tr><td>SD02_DSP_CID_SEIZURE_MODE</td><td align="center">14103(0x3717)</td><td> L1  DSP CID start state for seizure mode - upper byte (Bits 8-15)         </td><td width="100">0x40,
+</td></tr>
+<tr><td>SD02_DSP_THP2_KI[2]</td><td align="center">14104(0x3718)</td><td> L2  DSP   THP2 - ki - input scaling factor - Currently unused </td><td width="100">0x10,
+
+0x00,
+</td></tr>
+<tr><td>SD02_DSP_TXV[2]</td><td align="center">14106(0x371A)</td><td> L2  AUDIO  TX volume control  </td><td width="100">0x23,
+
+0xBC,
+</td></tr>
+<tr><td>SD02_DSP_RXV[2]</td><td align="center">14108(0x371C)</td><td> L2  AUDIO  RX volume control     </td><td width="100">0x10,
+
+0x00,
+</td></tr>
+<tr><td>SD02_DSP_RLP[2]</td><td align="center">14110(0x371E)</td><td> L2  AUDIO   RLP volume control     </td><td width="100">0x20,
+
+0x00,
+</td></tr>
+<tr><td>SD02_AFE_AFELGC1</td><td align="center">14112(0x3720)</td><td> L1  AFE gains  </td><td width="100">0x23,
+</td></tr>
+<tr><td>SD02_AFE_AFEMSGC1_NORMAL</td><td align="center">14113(0x3721)</td><td> L1  AFE gains normal mode </td><td width="100">0x32,
+</td></tr>
+<tr><td>SD02_MIN_RING_ON</td><td align="center">14114(0x3722)</td><td> min. DAEV_RING_ON    </td><td width="100">2,
+</td></tr>
+<tr><td>SD02_MIN_RING_OFF</td><td align="center">14115(0x3723)</td><td> min. DAEV_RING_OFF   </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_MIN_DTMF_ON</td><td align="center">14116(0x3724)</td><td> min. DAEV_DTMF_ON    </td><td width="100">2,
+</td></tr>
+<tr><td>SD02_MIN_DTMF_OFF</td><td align="center">14117(0x3725)</td><td> min. DAEV_DTMF_OFF   </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_MIN_CPDS_ON</td><td align="center">14118(0x3726)</td><td> min. DAEV_CPDS_ON    </td><td width="100">2,
+</td></tr>
+<tr><td>SD02_MIN_CPDS_OFF</td><td align="center">14119(0x3727)</td><td> min. DAEV_CPDS_OFF   </td><td width="100">2,
+</td></tr>
+<tr><td>SD02_MIN_CPDB_ON</td><td align="center">14120(0x3728)</td><td> min. DAEV_CPDB_ON    </td><td width="100">4,
+</td></tr>
+<tr><td>SD02_MIN_CPDB_OFF</td><td align="center">14121(0x3729)</td><td> min. DAEV_CPDB_OFF   </td><td width="100">4,
+</td></tr>
+<tr><td>SD02_MIN_FXD1_ON</td><td align="center">14122(0x372A)</td><td> min. DAEV_FXD1_ON    </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_MIN_FXD1_OFF</td><td align="center">14123(0x372B)</td><td> min. DAEV_FXD1_OFF   </td><td width="100">1,
+</td></tr>
+<tr><td>SD02_MIN_FXD2_ON</td><td align="center">14124(0x372C)</td><td> min. DAEV_FXD2_ON    </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_MIN_FXD2_OFF</td><td align="center">14125(0x372D)</td><td> min. DAEV_FXD2_OFF   </td><td width="100">1,
+</td></tr>
+<tr><td>SD02_MIN_GTD1_ON</td><td align="center">14126(0x372E)</td><td> min. DAEV_GTD1_ON    </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_MIN_GTD1_OFF</td><td align="center">14127(0x372F)</td><td> min. DAEV_GTD1_OFF   </td><td width="100">1,
+</td></tr>
+<tr><td>SD02_MIN_CAS_ON</td><td align="center">14128(0x3730)</td><td> min. DAEV_CAS_ON     </td><td width="100">2,
+</td></tr>
+<tr><td>SD02_MIN_CAS_OFF</td><td align="center">14129(0x3731)</td><td> min. DAEV_CAS_OFF    </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_MIN_CAS_REQUIRED</td><td align="center">14130(0x3732)</td><td> min. DAEV_CAS_REQUIRED </td><td width="100">0x60,
+</td></tr>
+<tr><td>SD02_DTMF_ON</td><td align="center">14131(0x3733)</td><td> min. DTMF tone on duration </td><td width="100">40,
+</td></tr>
+<tr><td>SD02_DTMF_OFF</td><td align="center">14132(0x3734)</td><td> min. pause after DTMF </td><td width="100">40,
+</td></tr>
+<tr><td>SD02_DIAL_PAUSE</td><td align="center">14133(0x3735)</td><td> min. dial pause      </td><td width="100">125,
+</td></tr>
+<tr><td>SD02_DTMF_VOL_LOW</td><td align="center">14134(0x3736)</td><td> V6dB low DTMF frequency </td><td width="100">0x40,
+</td></tr>
+<tr><td>SD02_DTMF_VOL_LOW_HIGH</td><td align="center">14135(0x3737)</td><td> V6dB low DTMF frequency high </td><td width="100">0x24,
+</td></tr>
+<tr><td>SD02_DTMF_VOL_HIGH</td><td align="center">14136(0x3738)</td><td> V6dB high DTMF frequency </td><td width="100">0xB0,
+</td></tr>
+<tr><td>SD02_DTMF_VOL_HIGH_HIGH</td><td align="center">14137(0x3739)</td><td> V6dB high DTMF frequency high </td><td width="100">0x2D,
+</td></tr>
+<tr><td>SD02_PULSE_MAKE_LENGTH</td><td align="center">14138(0x373A)</td><td> L1  PSTN:dialPULSE </td><td width="100">40,
+</td></tr>
+<tr><td>SD02_PULSE_BREAK_LENGTH</td><td align="center">14139(0x373B)</td><td> L1  PSTN:dialPULSE </td><td width="100">60,
+</td></tr>
+<tr><td>SD02_PULSE_IDP_LENGTH</td><td align="center">14140(0x373C)</td><td> L1  PSTN:dialPULSE </td><td width="100">80,
+</td></tr>
+<tr><td>SD02_LCURRENT_CYCLE</td><td align="center">14141(0x373D)</td><td> L1  PSTN:PCA1070   </td><td width="100">50,
+</td></tr>
+<tr><td>SD02_LCURRENT_IDP</td><td align="center">14142(0x373E)</td><td> L1  PSTN:PCA1070   </td><td width="100">32,
+</td></tr>
+<tr><td>SD02_PAUSE_LENGTH</td><td align="center">14143(0x373F)</td><td> L1  PSTN/AUDIO:dial</td><td width="100">30,
+</td></tr>
+<tr><td>SD02_FLASH_LENGTH</td><td align="center">14144(0x3740)</td><td> L1  PSTN:dial      </td><td width="100">10,
+</td></tr>
+<tr><td>SD02_EARTH_LENGTH</td><td align="center">14145(0x3741)</td><td> L1  PSTN:dial      </td><td width="100">40,
+</td></tr>
+<tr><td>SD02_RING_MIN</td><td align="center">14146(0x3742)</td><td> L1  PSTN:ringer    </td><td width="100">18,
+</td></tr>
+<tr><td>SD02_RING_MAX</td><td align="center">14147(0x3743)</td><td> L1  PSTN:ringer    </td><td width="100">50,
+</td></tr>
+<tr><td>SD02_RON_DETECT</td><td align="center">14148(0x3744)</td><td> L1  PSTN:ringer    </td><td width="100">9,
+</td></tr>
+<tr><td>SD02_RON_HOLD</td><td align="center">14149(0x3745)</td><td> L1  PSTN:ringer    </td><td width="100">20,
+</td></tr>
+<tr><td>SD02_ROFF_DETECT</td><td align="center">14150(0x3746)</td><td> L1  PSTN:ringer    </td><td width="100">11,
+</td></tr>
+<tr><td>SD02_ROFF_HOLD</td><td align="center">14151(0x3747)</td><td> L1  PSTN:ringer    </td><td width="100">25,
+</td></tr>
+<tr><td>SD02_LIF_CURR_LO</td><td align="center">14152(0x3748)</td><td> L1  PSTN:l.current </td><td width="100">0,
+</td></tr>
+<tr><td>SD02_LIF_CURR_HI</td><td align="center">14153(0x3749)</td><td> L1    +1           </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_WETTING_TIME</td><td align="center">14154(0x374A)</td><td> L1  Wetting Pulse  </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_DTMF_D_TIME</td><td align="center">14155(0x374B)</td><td> L1  DTMF-D for CAS </td><td width="100">0x23,
+</td></tr>
+<tr><td>SD02_STUTTER_CYCLES</td><td align="center">14156(0x374C)</td><td> L1  # of Stutter   </td><td width="100">0x0A,
+</td></tr>
+<tr><td>SD02_CID_DET_ENBL_TIME</td><td align="center">14157(0x374D)</td><td> L1  CID detection 100ms steps </td><td width="100">38,
+</td></tr>
+<tr><td>SD02_FSK_START_TIME</td><td align="center">14158(0x374E)</td><td> L1  CID-2 detection </td><td width="100">0xE0,
+</td></tr>
+<tr><td>SD02_FSK_OFFHOOK_TIME[2]</td><td align="center">14159(0x374F)</td><td> L2  CID-2 detection </td><td width="100">0xAD,
+
+0x03,
+</td></tr>
+<tr><td>SD02_AFE_AFEMSGC1_HF</td><td align="center">14161(0x3751)</td><td> L1  AFE gains for Handsfree </td><td width="100">0x32,
+</td></tr>
+<tr><td>SD02_AFE_AFEMSGC2</td><td align="center">14162(0x3752)</td><td> L1  AFE gains </td><td width="100">0x51,
+</td></tr>
+<tr><td>SD02_EAR_VOL_TAB[10]</td><td align="center">14163(0x3753)</td><td> L10 10 volume values for polyphonic ringing (increasing order)</td><td width="100">0x02,0x03,0x04,0x06,0x08,
+
+0x09,0x0A,0x0B,0x0c,0x0d,
+</td></tr>
+<tr><td>SD02_RVBC1C_VAL</td><td align="center">14173(0x375D)</td><td> L1 Codec 1 (In base Spk) control </td><td width="100">0xC0,
+</td></tr>
+<tr><td>SD02_RVBC1G_VAL</td><td align="center">14174(0x375E)</td><td> L1 Codec 1 (In base Spk) gain </td><td width="100">0x4F,
+</td></tr>
+<tr><td>SD02_RVBC1C_VAL_HF</td><td align="center">14175(0x375F)</td><td> L1 Codec 1 (In base Spk) control for HF</td><td width="100">0xC0,
+</td></tr>
+<tr><td>SD02_RVBC1G_VAL_HF</td><td align="center">14176(0x3760)</td><td> L1 Codec 1 (In base Spk) gain for HF</td><td width="100">0x4F,
+</td></tr>
+<tr><td>SD02_WBE_ENABLE</td><td align="center">14177(0x3761)</td><td> L1   WBE_FT Enable </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_RVDDC_FIX_ENABLE</td><td align="center">14178(0x3762)</td><td> L1  ENABLE/DISABLE Patch for RVDCDC HW bug</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_INBAND_TONE_SELECT</td><td align="center">14179(0x3763)</td><td> L1  Select country for inband tone  </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_DRV_UNUSED</td><td align="center">14180(0x3764)</td><td>   <----------- unused </td><td width="100">0xFF,</td></tr>
+<tr><td>SD02_ALLOC_LINE1[2]</td><td align="center">14180(0x3764)</td><td>handset allocation (see Protocol Interface)													   bitwise per handset: 1 = handset allocated;
+													   (0xFF 0xFF indicates Collective ringing)  for 
+													   each of the next 3 lines</td><td width="100">0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_ALLOC_LINE2[2]</td><td align="center">14182(0x3766)</td><td></td><td width="100">0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_ALLOC_LINE3[2]</td><td align="center">14184(0x3768)</td><td></td><td width="100">0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_HS_TYPE_CATIQ30</td><td align="center">14186(0x376A)</td><td> Tells HS is CatIQ30 capable implemented for Max 8 HS only </td><td width="100">0x0,
+</td></tr>
+<tr><td>SD02_WB_TYPE_HSNR[2]</td><td align="center">14187(0x376B)</td><td> PT WB capability storage Note:For CAT-IQ builds user should not  modify this location</td><td width="100">0,0,
+</td></tr>
+<tr><td>SD02_WB_LINE_TYPE</td><td align="center">14189(0x376D)</td><td> FT Line TYPE storgare(2= G711WB, 1 = WB , 0 =NB) </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_WB_LINE_SUB_TYPE</td><td align="center">14190(0x376E)</td><td> FT WB Line Sub Type ( 0 = G722 WB, 1 = G711 WB) </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_DH_MIX_RATIO</td><td align="center">14191(0x376F)</td><td></td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_NEMO_PTS[2]</td><td align="center">14192(0x3770)</td><td> Two Bytes are used</td><td width="100">0xFF,0xFF,
+</td></tr>
+<tr><td>SD02_SPK_SLOT_TYPE</td><td align="center">14194(0x3772)</td><td> Slot type for SPK phone</td><td width="100">0x02,
+</td></tr>
+<tr><td>SD02_MAX_NUM_ACT_CALLS_PT</td><td align="center">14195(0x3773)</td><td> Maximum nmber of active calls of 1 PT.</td><td width="100">0x03,
+</td></tr>
+<tr><td>SD02_NEMO_DISABLED</td><td align="center">14196(0x3774)</td><td> bit 7 is used for permanent NEMo disable </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_HS_TYPE_CATIQ20[2]</td><td align="center">14197(0x3775)</td><td> L2: Two bytes for CAT-iq 2.0 Handset </td><td width="100">0x00,
+
+0x00,
+</td></tr>
+<tr><td>SD02_FP_CUSTOM_FEATURES</td><td align="center">14199(0x3777)</td><td> Bit-0: INL 0-enable/1-disable, Bit-1: 0-conf,trfr enable/1-conf,trfr disable</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_ENCRYPT_STATUS</td><td align="center">14200(0x3778)</td><td> L1: Encryption enable/disable</td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_MM_CAPABILITIES[10]</td><td align="center">14201(0x3779)</td><td> L10: MM Capabilities for each Handset.FTEEP_NUM_SUB/SD09_MAX_NUM_SUB is hard coded as 10 </td><td width="100">0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,
+
+0x00,0x00,
+</td></tr>
+<tr><td>SD02_ARBITRARY_TPUI[3]</td><td align="center">14211(0x3783)</td><td> L3 : 3 bytes to store arbitrary TPUI</td><td width="100">0x00,0x00,0x00,
+</td></tr>
+<tr><td>SD02_HS_TYPE_CATIQ21[2]</td><td align="center">14214(0x3786)</td><td> L2: Two bytes for CAT-iq 2.1 Handset </td><td width="100">0x00,0x00,
+</td></tr>
+<tr><td>SD02_INTERFERENCE_DETECTION_MEASUREMENT_INTERVAL</td><td align="center">14216(0x3788)</td><td> L1: Interference Detection Measurement Interval </td><td width="100">60,
+</td></tr>
+<tr><td>SD02_INTERFERENCE_DETECTION_NOISE_INTERVAL</td><td align="center">14217(0x3789)</td><td> L1: Interference Detection Noise Interval </td><td width="100">30,
+</td></tr>
+<tr><td>SD02_INTERFERENCE_DETECTION_CONFIG1</td><td align="center">14218(0x378A)</td><td> L1: Interference Detection config1, bit 0-7: Active Carriers Mask, carriers 1-8 </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_INTERFERENCE_DETECTION_CONFIG2</td><td align="center">14219(0x378B)</td><td> L1: Interference Detection config2, bit 0-1: Active Carriers Mask, carriers 9-10; bit7: 1-Enable/0-Disable Interference Detection alg.</td><td width="100">0x83,
+</td></tr>
+<tr><td>SD02_INTERFERENCE_DETECTION_TRAFFIC_SLOTS_IN_FRAME</td><td align="center">14220(0x378C)</td><td> L1: Interference Detection Traffic Slots In Frame </td><td width="100">0x03,
+</td></tr>
+<tr><td>SD02_INTERFERENCE_DETECTION_INTERFERENCE_LEVEL</td><td align="center">14221(0x378D)</td><td> L1: Interference Detection Interference Level </td><td width="100">0x98,
+</td></tr>
+<tr><td>SD02_NEMO_CONTROL</td><td align="center">14222(0x378E)</td><td> L1: MSB enables HM00_NEMO_DUMMY_USE_RSSI_FOR_IF_CHECK, others are for extending NEMO WA bearer time </td><td width="100">0x00,
+</td></tr>
+<tr><td>FCAC_HLP_END</td><td align="center">14223(0x378F)</td><td>   </td><td width="100"></td></tr>
+<tr><td>SD02_RINGER_EXPIRY</td><td align="center">14223(0x378F)</td><td> L1 FTMI:X line   </td><td width="100">45,
+</td></tr>
+<tr><td>SD02_LINE_EXPIRY</td><td align="center">14224(0x3790)</td><td> L1 FTMI:release  </td><td width="100">85,
+</td></tr>
+<tr><td>SD02_RINGER_MELODY</td><td align="center">14225(0x3791)</td><td> L1 FTMI:ringer   </td><td width="100">9,
+</td></tr>
+<tr><td>SD02_RINGER_VOLUME</td><td align="center">14226(0x3792)</td><td> L1 FTMI:ringer   </td><td width="100">3,
+</td></tr>
+<tr><td>SD02_DIAL_MODI</td><td align="center">14227(0x3793)</td><td> L1 FTMI:dtmf/reca</td><td width="100">0xD3,
+</td></tr>
+<tr><td>SD02_DLT_CTRL</td><td align="center">14228(0x3794)</td><td> L1 FTMI:dialTone </td><td width="100">0x3A,
+</td></tr>
+<tr><td>SD02_TONDET_SEL</td><td align="center">14229(0x3795)</td><td> L1 FTMI:ena/disa   enable tone detection features:																		0x80: DTAS
+																		0x40: RPAS
+																		0x41: RPASFR
+																		0x20: MFCR</td><td width="100">0x80+0x41+0x20,
+</td></tr>
+<tr><td>SD02_LRMS_SUPPORT[2]</td><td align="center">14230(0x3796)</td><td> L2 FTMI:LRMS sup. 														1 Bit per handset. 1 indicates LMRS support
+														of the according handset.</td><td width="100">0x00, 0x00,
+</td></tr>
+<tr><td>SD02_SMS1_PLUS_SUPPORT[2]</td><td align="center">14232(0x3798)</td><td> L2 FTMI:SMS1_PLUS sup. 															1 Bit per handset. 1 indicates SMS1+ support
+															of the according handset.</td><td width="100">0x00, 0x00,
+</td></tr>
+<tr><td>SD02_COUNTRY_IDENTIFICATION</td><td align="center">14234(0x379A)</td><td> L1 FTMMS         </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_SMS_TP_MR</td><td align="center">14235(0x379B)</td><td> L1 FTMMS         </td><td width="100">0xfd,
+</td></tr>
+<tr><td>SD02_DTAM_RING</td><td align="center">14236(0x379C)</td><td> DTAM: ringtones  </td><td width="100">0x5,
+</td></tr>
+<tr><td>SD02_PREF_LINE[9]</td><td align="center">14237(0x379D)</td><td> L9  FTMI:ogo line, up to 9 </td><td width="100">0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,
+</td></tr>
+<tr><td>SD02_PRIOR_HS[30]</td><td align="center">14246(0x37A6)</td><td> L2 FTMI:inc line, up to 3 														incoming prioritized HS line 1
+														ring count of prior. HS line 1
+														incoming prioritized HS line 2
+														ring count of prior. HS line 2
+														incoming prioritized HS line 3
+														ring count of prior. HS line 3</td><td width="100">0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+
+0x00,
+</td></tr>
+<tr><td>SD02_BLINDCALL_TIM1</td><td align="center">14276(0x37C4)</td><td> Blind call transfer timeout 1 </td><td width="100">0x1E,
+</td></tr>
+<tr><td>SD02_BLINDCALL_TIM2</td><td align="center">14277(0x37C5)</td><td> Blind call transfer timeout 2 </td><td width="100">0x1E,
+</td></tr>
+<tr><td>SD02_PARKED_TIM</td><td align="center">14278(0x37C6)</td><td> Parked line timeout </td><td width="100">0x3c,
+</td></tr>
+<tr><td>SD02_OVERLAP_SEND_TIM</td><td align="center">14279(0x37C7)</td><td> Overlap sending timer </td><td width="100">0x4,
+</td></tr>
+<tr><td>SD02_DTAM_ENABLE</td><td align="center">14280(0x37C8)</td><td> DTAM: ON/OFF       </td><td width="100">0x1,
+</td></tr>
+<tr><td>SD02_DTAM_ICM_CR</td><td align="center">14281(0x37C9)</td><td> DTAM: codRates ICM </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_DTAM_OGM_CR</td><td align="center">14282(0x37CA)</td><td> DTAM: codRates OGM </td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_DTAM_PILL_CR</td><td align="center">14283(0x37CB)</td><td> DTAM: codRates Pill</td><td width="100">0xFF,
+</td></tr>
+<tr><td>SD02_EARVOL</td><td align="center">14284(0x37CC)</td><td> EAR Vol </td><td width="100">0x05,
+</td></tr>
+<tr><td>SD02_BS_CALL_SCREENING</td><td align="center">14285(0x37CD)</td><td> L1 Call Screening Enable/disable</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_EMC_COMPLIANT[2]</td><td align="center">14286(0x37CE)</td><td> L2 stores the compliant of PT's i.e. whether EMC is equal </td><td width="100">0x00, 0x00,
+</td></tr>
+<tr><td>SD02_LU10_RN_UPDATE</td><td align="center">14288(0x37D0)</td><td> L1 Enable/disable update RN=SN+1 </td><td width="100">0x05,
+</td></tr>
+<tr><td>SD02_MMI_DECT_SECURITY</td><td align="center">14289(0x37D1)</td><td> L1 DECT SECURITY LEVEL </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_CR_PREFERRED_CODEC</td><td align="center">14290(0x37D2)</td><td> L1 holds the preferred codec for CR </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_PAD_OPT_NORMAL</td><td align="center">14291(0x37D3)</td><td> L1 holds the Normal action for CR: 0- nothing 1 - Mute</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_PAD_OPT_PROTECTED</td><td align="center">14292(0x37D4)</td><td> L1 holds the Protected action for CR: 0- nothing 1 - Mute</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_CR_ACTION_ADPCM</td><td align="center">14293(0x37D5)</td><td> L1 holds the ADPCM action for  0- nothing 1 - Improved</td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_CLEARANGE_ENABLE</td><td align="center">14294(0x37D6)</td><td> L1 Enable CR feature </td><td width="100">0x01,
+</td></tr>
+<tr><td>SD02_REPEATER_TYPE</td><td align="center">14295(0x37D7)</td><td> L1 Hold the Repeater Type GAP,CAT-iq.NEMO </td><td width="100">0x00,
+</td></tr>
+<tr><td>SD02_ULE_MULTICAST_ENC_PARAMS[53]</td><td align="center">14296(0x37D8)</td><td> L48  ULE Multicast enc. parameter: 2x (CCM key, sequence number, Multicast ID) </td><td width="100">0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,0x00,0x00,
+
+0x00,0x00,0x00,
+
+0xFF,
+
+0x0,
+
+0x0,
+
+0x0, 0x00,
+</td></tr>
+<tr><td>SD02_DECT_SETTINGS_OFFSET</td><td align="center">14349(0x380D)</td><td>  DECT settings List Offset </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_CLOCK_MASTER</td><td align="center">14349(0x380D)</td><td> L1 </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_BASE_RESET</td><td align="center">14350(0x380E)</td><td> L1  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_FW_VERSION[38]</td><td align="center">14351(0x380F)</td><td> L8  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_EEP_VERSION[38]</td><td align="center">14389(0x3835)</td><td> L8  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_HW_VERSION[38]</td><td align="center">14427(0x385B)</td><td> L8   </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_NEW_PIN[4]</td><td align="center">14465(0x3881)</td><td> L4  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_EMISSION_MODE</td><td align="center">14469(0x3885)</td><td> L1 </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_IP_TYPE</td><td align="center">14470(0x3886)</td><td> L1  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_IP_VALUE[17]</td><td align="center">14471(0x3887)</td><td> L17  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_IP_SUBNET_MASK[17]</td><td align="center">14488(0x3898)</td><td> L17  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_IP_GATEWAY[17]</td><td align="center">14505(0x38A9)</td><td> L17  </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_IP_DNS_SERVER[17]</td><td align="center">14522(0x38BA)</td><td> L17 </td><td width="100"></td></tr>
+<tr><td>SD02_DSSL_FP_POWER_LEVEL</td><td align="center">14539(0x38CB)</td><td> L1   </td><td width="100"></td></tr>
+<tr><td>SD02_LINE_SETTINGS_OFFSET[75]</td><td align="center">14540(0x38CC)</td><td>  Line Settings List Offset </td><td width="100"></td></tr>
+<tr><td>SD02_INL_DATA_OFFSET[375]</td><td align="center">14615(0x3917)</td><td>  Internal Name List Offset </td><td width="100"></td></tr>
+<tr><td>SD02_SUPTD_LIST_OFFSET[22]</td><td align="center">14990(0x3A8E)</td><td> Supported List Offset</td><td width="100"></td></tr>
+<tr><td>SD02_BSNAME_LEN</td><td align="center">15012(0x3AA4)</td><td> L1  </td><td width="100"></td></tr>
+<tr><td>SD02_BSNAME[19]</td><td align="center">15013(0x3AA5)</td><td> L13 Bytes of data MAX  </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_IPUI[5]</td><td align="center">15032(0x3AB8)</td><td> L5   Data: IPUI </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_TPUI[3]</td><td align="center">15037(0x3ABD)</td><td> L3   Data: TPUI </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_DCK[16]</td><td align="center">15040(0x3AC0)</td><td> L16  Data: DCK </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_UAK[16]</td><td align="center">15056(0x3AD0)</td><td> L16  Data: UAK </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_AC[4]</td><td align="center">15072(0x3AE0)</td><td> L4   Data: authentication code AC </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_UAK_AUTH</td><td align="center">15076(0x3AE4)</td><td> L1   Data: UAK authorization </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_STATUS</td><td align="center">15077(0x3AE5)</td><td> L1   Data: status </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_HANDSET_NR</td><td align="center">15078(0x3AE6)</td><td> L1   Data: handset number </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_DCK_ASSIGNED</td><td align="center">15079(0x3AE7)</td><td> L1   Data: DCK assigned </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_CK_LEN</td><td align="center">15080(0x3AE8)</td><td> L1   Data: Cipher Key Length  </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_FEATURES</td><td align="center">15081(0x3AE9)</td><td> L1     Data: Handset ULE feature support </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_LEN[15032]</td><td align="center">50(0x32)</td><td>   End of first subscribtion </td><td width="100"></td></tr>
+<tr><td>FNCA_SUB(i)[250]</td><td align="center">15082(0x3AEA)</td><td>   This place is reserved for the rest of the HS and includes all perameters:SD02_SUB_IPUI-SD02_SUB_DCK_ASSIGNED (40Byte x Number of handsets)</td><td width="100"></td></tr>
+<tr><td>SD02_SUB_UNUSED[6]</td><td align="center">15332(0x3BE4)</td><td>  <----------- unused </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_EX_DEFCK[16]</td><td align="center">15338(0x3BEA)</td><td> L16  Data: Default Cipher Key </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_EX_DEFCK_ASSIGNED</td><td align="center">15354(0x3BFA)</td><td> L1   Data: DefCK assigned </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_EX_LEN[15338]</td><td align="center">17(0x11)</td><td>   End of first subscribtion </td><td width="100"></td></tr>
+<tr><td>FNCA_SUB_EX(i)[85]</td><td align="center">15355(0x3BFB)</td><td>   This place is reserved for the rest of the HS and includes all perameters:SD02_SUB_IPUI-SD02_SUB_DCK_ASSIGNED (40Byte x Number of handsets)</td><td width="100"></td></tr>
+<tr><td>SD02_SUB_EX_UNUSED[4]</td><td align="center">15440(0x3C50)</td><td>  <----------- unused </td><td width="100"></td></tr>
+<tr><td>SD02_SUB_RFPI</td><td align="center">15444(0x3C54)</td><td> L5    RFPI </td><td width="100"></td></tr>
+</tbody>
+</table>
+
+	<h3>EEPROM SIZE = 32768</h3>
+
+	<h6>*All non exists values on default are zero upon EEPROM reset</h6>
+

dectmngr/files/scripts/load_sound_modules.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+SOUND_BASE=/lib/modules/$(uname -r)/kernel/sound
+SOUND_MODULES="$SOUND_BASE/soundcore.ko $SOUND_BASE/core/snd.ko $SOUND_BASE/core/snd-timer.ko"
+SOUND_MODULES="$SOUND_MODULES $SOUND_BASE/core/snd-pcm.ko $SOUND_BASE/core/snd-hwdep.ko"
+SOUND_MODULES="$SOUND_MODULES $SOUND_BASE/core/seq/snd-seq-device.ko"
+SOUND_MODULES="$SOUND_MODULES $SOUND_BASE/core/seq/snd-seq.ko $SOUND_BASE/core/snd-rawmidi.ko "
+SOUND_MODULES="$SOUND_MODULES $SOUND_BASE/usb/snd-usbmidi-lib.ko $SOUND_BASE/usb/snd-usb-audio.ko"
+
+load_sound_modules() {
+	for mod in $SOUND_MODULES; do
+		insmod $mod
+	done
+}
+
+unload_sound_modules() {
+	local modules=
+
+	# reverse the order
+	for mod in $SOUND_MODULES; do
+		modules="$mod $modules"
+	done
+
+	for mod in $modules; do
+		rmmod $mod
+	done
+}

dectmngr/src/LICENSE

@@ -0,0 +1,308 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    dspg_test_app - DSPG CMBS Host Software Test Application
+    Copyright (C) 2020  iopsys Software Solutions AB
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

dectmngr/src/Makefile

@@ -0,0 +1,6 @@
+
+.PHONY: dspg_test_app
+
+dspg_test_app:
+	$(MAKE) -C test
+

dectmngr/src/cmbs/cmbs.mak

@@ -0,0 +1,42 @@
+ifdef CMBSDIR 
+CMBSBASE:=$(CMBSDIR)/cmbs
+includes += -I$(CMBSDIR)/include 
+else
+CMBSBASE:=$(PROJDIR)/cmbs
+endif
+
+includes += -I$(CMBSBASE)
+cmbs_objects:=
+####################################################################
+# settle includes
+
+#includes += -I$(FRAMEBASE) -I$(FRAMEBASE)/vone 
+####################################################################
+# settle objects
+
+ifdef CMBS_HOST
+OBJ_EXT = o
+else
+OBJ_EXT = otwi
+endif
+
+cmbs_objects += $(OBJDIR)/cmbs_int.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_api.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_dcm.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_dsr.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_dee.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_dem.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_ie.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_cmd.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_suota.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_rtp.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_util.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_fifo.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_dbg.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_han.$(OBJ_EXT)
+cmbs_objects += $(OBJDIR)/cmbs_han_ie.$(OBJ_EXT)
+
+####################################################################
+# settle vpath
+
+vpath %.c 	$(CMBSBASE)

dectmngr/src/cmbs/cmbs_api.c

@@ -0,0 +1,118 @@
+/*!
+*	\file			cmbs_api.c
+*	\brief			API Maintenance functions
+*	\Author			CMBS Team 
+*
+*	@(#)	%filespec: cmbs_api.c~DMZD53#7 %
+*
+*******************************************************************************/
+#include <string.h>
+#include "cmbs_int.h"
+
+#define TARGET_ANSWER_TIMEOUT	10000
+ST_CB_LOG_BUFFER g_LogBufferCb;
+
+#ifdef __linux
+extern void _cmbs_int_MsgQDestroy(int nMsgQId);
+extern int _cmbs_int_MsgQCreate(void);
+#endif
+
+/*****************************************************************************
+* API Maintenance functions
+*****************************************************************************/
+PST_CB_LOG_BUFFER cmbs_api_get_LogBufferCb(void)
+{
+	return &g_LogBufferCb;
+}
+
+
+E_CMBS_RC cmbs_api_Init( E_CMBS_API_MODE e_Mode, ST_CMBS_DEV * pst_DevCtl, ST_CMBS_DEV * pst_DevMedia )
+{
+#if !defined ( CMBS_API_TARGET )
+  E_CMBS_RC ReturnCode;
+#endif
+
+	// initialize host environment
+	if(cmbs_int_EnvCreate( e_Mode, pst_DevCtl, pst_DevMedia ) != CMBS_RC_OK)
+		return CMBS_RC_ERROR_GENERAL;
+
+	memcpy(&g_CMBSInstance.st_ApplSlot.pFnCbLogBuffer, cmbs_api_get_LogBufferCb(), sizeof(ST_CB_LOG_BUFFER));
+
+#if !defined ( CMBS_API_TARGET )
+	// establish communication with the module
+	cmbs_int_SendHello(pst_DevCtl, pst_DevMedia);
+	// wait for target answer
+	ReturnCode = cmbs_int_WaitForResponse(TARGET_ANSWER_TIMEOUT);
+    
+    if (ReturnCode == CMBS_RC_OK)
+    {
+        if (g_CMBSInstance.u16_TargetVersion != 0x0001)
+        {
+            // try to get Target capabilities (if no response, it means target does not support this message)
+            cmbs_int_cmd_SendCapablities(); 
+            cmbs_int_WaitForResponse(TARGET_ANSWER_TIMEOUT);
+        }
+    }
+    return ReturnCode;
+#else
+	return CMBS_RC_OK;
+#endif
+}
+
+void cmbs_api_UnInit( void )
+{   
+	cmbs_int_EnvDestroy();
+}
+
+void* cmbs_api_RegisterCb( void * pv_AppRef, PFN_CMBS_API_CB pfn_api_Cb, u16 u16_bcdVersion )
+{   
+	return cmbs_int_RegisterCb( pv_AppRef, pfn_api_Cb, u16_bcdVersion );
+}
+
+void cmbs_api_UnregisterCb( void * pv_AppRefHandle )
+{
+	cmbs_int_UnregisterCb( pv_AppRefHandle );
+}
+
+u16 cmbs_api_ModuleVersionGet( void )
+{
+	return cmbs_int_ModuleVersionGet();
+}
+
+u16 cmbs_api_ModuleVersionBuildGet( void )
+{
+	return cmbs_int_ModuleVersionBuildGet();
+}
+
+#ifdef __linux
+void  cmbs_api_MsgQDestroy(int nMsgQId)
+{
+	  _cmbs_int_MsgQDestroy(nMsgQId);
+}
+int  cmbs_api_MsgQCreate(void)
+{
+	  return _cmbs_int_MsgQCreate();
+}
+#elif WIN32
+void  cmbs_api_MsgQDestroy(PST_ICOM_ENTRY pMsgQId)
+{
+ 	cfr_MQueueDestroy ( pMsgQId);
+}		
+PST_ICOM_ENTRY  cmbs_api_MsgQCreate(u32 u32_ThreadID, u32 u32_Timeout)
+{
+	return cfr_MQueueCreate(u32_ThreadID, u32_Timeout);
+}
+#endif
+
+void cmbs_api_RegisterLogBufferCb(void* pv_AppRef, PST_CB_LOG_BUFFER pfn_log_buffer_Cb)
+{
+	cmbs_int_RegisterLogBufferCb(pv_AppRef, pfn_log_buffer_Cb);
+}
+#if !defined( CMBS_API_TARGET )
+void cmbs_api_ParseDectMsg(u8 * buff, u8 u8_ILen, u8 u8_HandsetNumber)
+{
+	cmbs_int_ParseDectMsg(buff, u8_ILen, u8_HandsetNumber);
+}
+#endif //#if !defined( CMBS_API_TARGET )
+
+//*/

dectmngr/src/cmbs/cmbs_cmd.c

@@ -0,0 +1,769 @@
+/*!
+*  \file       cmbs_cmd.c
+*  \brief      Implementation of the CMBS internal command protocol
+*  \Author     kelbch
+*
+*  @(#)  %filespec: cmbs_cmd.c~DMZD53#16 %
+*
+*******************************************************************************
+*	\par	History
+*	\n==== History ============================================================\n
+*	date			name		version	 action                                          \n
+*	----------------------------------------------------------------------------\n
+* 13-Jan-2014 tcmc_asa  -- GIT--  take checksum changes from 3.46.x to 3_x main (3.5x)
+* 20-Dec-13 tcmc_asa   GIT  Added CHECKSUM_SUPPORT    
+* 16-Feb-09		Kelbch		1		Initialize \n
+* 18-Feb-09    Kelbch      2     Update Version information on Hello Reply \n
+* 18-Feb-09    Kelbch      3     Adapted Version information on Hello Reply \n
+* 19-Feb-09    Kelbch      4     Extend hello-reply procedure to block conditions\n
+* 19-Feb-09    Kelbch      5     Add flow control commands\n
+* 09-Apr-09    Kelbch      161   Update of Media Configuration during start-up \n
+*******************************************************************************/
+
+#if defined(__arm)
+#include "tclib.h"
+#include "embedded.h"
+#include <stdio.h>
+
+#include "bsd09cnf.h"      /* component-globalal, system configuration */
+#include "bsd09ddl.h"      /* messages and processes */
+#include "bsd02eep.h"
+#include "cdr03eep.h"
+
+#else
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#endif
+
+#include "cmbs_int.h"      // CMBS internal API structure and defines
+#include "cfr_debug.h"     // CMBS debug definition
+
+ST_CAPABLITIES    g_st_CMBSCapabilities;
+
+#if defined ( CMBS_API_TARGET )
+	#include "cfr_uart.h"
+	#include "tapp.h"
+	#include "tapp_log.h"
+	extern void _cfr_uartTransmitterReset( void );
+	extern void p_cmbs14_SuspendTxRes(u8 u8_Response);
+	extern void p_cmbs14_ResumeTxRes(u8 u8_Response);
+	extern ST_CMBS_APP g_CMBSApp;
+
+#if defined (CRASH_DUMP)
+	extern bool tapp_dsr_IsCrashDumpAvailable(void);
+#endif
+
+#if defined (CRASH_DUMP)
+#include "csys0reg.h"
+#include "csys2vpb.h"
+#include "csys5os.h"
+#endif
+
+#endif
+
+
+	extern void tapp_util_ConfigureUARTFlowCTRL(E_CMBS_FLOW_CTRL flowCTRL);
+    
+E_CMBS_RC         _cmbs_int_cmd_SendOPUSPayload(void);
+void              _cmbs_int_cmd_CapabilitiesReply(u8 *pu8_Buffer);
+void              _cmbs_int_cmd_Capabilities(u8 *pu8_Buffer);
+void              _cmbs_int_cmd_StoreRAMDump(void);
+int InitDuslicXS(void);
+int SLIC_init(void);
+//		========== _cmbs_int_cmd_Reset ===========
+/*!
+		\brief				 reset the communication module
+		\param[in]		 < none >
+		\return			 < none >
+*/
+void  _cmbs_int_cmd_Reset( void )
+{
+#ifdef OS_TASK_CONTROL
+   extern volatile u32 G_u32_tapp_ParamAreaGetRspFlag;
+   extern volatile u32 G_u32_tapp_ParamAreaGetRspOffset;
+   extern volatile u32 G_u32_tapp_ParamAreaGetRspDataLen;
+#endif // OS_TASK_CONTROL
+
+   CFR_DBG_OUT ( "CMBS-API: Reset communication module \n" ) ;
+#if defined ( CMBS_API_TARGET )
+   cfr_uartInitalize ( );
+#endif
+   g_CMBSInstance.e_DestFlowState = E_CMBS_FLOW_STATE_GO;
+   g_CMBSInstance.e_OrigFlowState = E_CMBS_FLOW_STATE_GO;
+
+#ifdef OS_TASK_CONTROL
+   G_u32_tapp_ParamAreaGetRspFlag = 0;
+   G_u32_tapp_ParamAreaGetRspOffset = 0;
+   G_u32_tapp_ParamAreaGetRspDataLen = 0;
+#endif // OS_TASK_CONTROL
+}
+
+//		========== _cmbs_int_cmd_Hello ===========
+/*!
+		\brief				 reset communication buffer and reply to host, ready to go.
+
+		\param[in,out]		 pu8_Buffer		 pointer to buffer, currently NULL, u16_Size size of buffer
+
+		\return				 < none >
+
+*/
+extern void  cmbs_applNewTDMReconfigure ( u8 u8_Master, u8 u8_Speed, u8 u8_Sync, u16 u16_SlotEnable, u8 u8_Loop );
+
+void _cmbs_int_cmd_Hello( u8 * pu8_Buffer, u16 u16_Size )
+{
+#if defined ( CMBS_API_TARGET )
+   u8 u8_Buffer[5];
+#if !defined( CMBS_USB_AUDIO )
+   u8 u8_Master = FALSE, u8_Loop = FALSE;
+#endif
+
+   if( pu8_Buffer )
+   {
+      CFR_DBG_OUT ( "CMBS-API: Receive Hello message with Media Information %02x %02x %02x\n",
+                    pu8_Buffer[0],
+                    pu8_Buffer[1],
+                    pu8_Buffer[2]
+                  );
+
+#if !defined( CMBS_USB_AUDIO )
+      switch ( pu8_Buffer[0])
+      {
+         case CMBS_TDM_TYPE_MASTER:
+            u8_Master = TRUE;
+            u8_Loop = FALSE;
+            break;
+         case CMBS_TDM_TYPE_SLAVE:
+            u8_Master = FALSE;
+            u8_Loop = FALSE;
+            break;
+         case CMBS_TDM_TYPE_MASTER_LOOP:
+            u8_Master = TRUE;
+            u8_Loop = TRUE;
+            break;
+         case CMBS_TDM_TYPE_SLAVE_LOOP:
+            u8_Master = FALSE;
+            u8_Loop = TRUE;
+            break;
+      }
+#ifndef NEW_TDM
+      cmbs_applTDMReconfigure( u8_Master, pu8_Buffer[1], pu8_Buffer[2], 0xFFFF, u8_Loop );
+#else
+      cmbs_applNewTDMReconfigure( u8_Master, pu8_Buffer[1], pu8_Buffer[2], 0xFFFF, u8_Loop );
+#endif //NEW_TDM
+#endif //!defined( CMBS_USB_AUDIO )
+			
+		if (u16_Size > LEGACY_CMD_HELLO_LENGTH)	//means we also received UART Flow control configuration	
+	{ 
+#if (defined (UART) && !defined(USB)) || defined (CMBS_UART) 
+	   CFR_DBG_OUT ( "CMBS-API: Receive Hello message with UART Configuration %02x\n", pu8_Buffer[5]);
+		tapp_util_ConfigureUARTFlowCTRL(pu8_Buffer[5]);
+#endif
+	}
+
+   }
+   else
+   {
+      CFR_DBG_OUT ( "CMBS-API: Receive Hello message without Media Information\n" );
+   }
+
+	// (Re-)Init transmit (to avoid problem occurred with USB, when old info is still in buffer when serial port is closed)
+   _cfr_uartTransmitterReset();
+
+   _cmbs_int_cmd_Reset();
+
+   cfr_ie_ser_u16( u8_Buffer, CMBS_API_TARGET_VERSION );
+   cfr_ie_ser_u16( u8_Buffer+sizeof(u16),CMBS_TARGET_BUILD );
+
+   u8_Buffer[4] = g_CMBSInstance.e_Mode;
+
+#ifdef QSPIC_EEPROM
+	p_dr13_EEPONF_DisableFlashing(); // should call p_cmbs14_ResumeTxRes instead ?
+#endif
+
+#ifdef CMBS_TARGET_UP_RETRANSMISSION
+	tapp_dsr_UpdateHelloArrived(true);
+#endif 
+
+    tapp_util_Release_All_External_Calls(&g_CMBSApp);	// If any Open Call
+
+   cmbs_int_cmd_Send( (u8)CMBS_CMD_HELLO_RPLY, u8_Buffer, sizeof(u8_Buffer) );
+#else
+	UNUSED_PARAMETER(u16_Size);
+#endif // CMBS_API_TARGET
+
+
+
+	UNUSED_PARAMETER( pu8_Buffer );
+}
+
+//		========== _cmbs_int_cmd_HelloRply ===========
+/*!
+		\brief				 target reply received, get version info of target
+
+		\param[in,out]		 pu8_Buffer		 pointer to parameter, e.g. version info,etc.
+
+		\return				< none >
+
+*/
+
+void  _cmbs_int_cmd_HelloRply( u8 * pu8_Buffer )
+{
+#if !defined ( CMBS_API_TARGET )
+   u16 u16_Version;
+
+   cfr_ie_dser_u16 (pu8_Buffer, &u16_Version );
+
+   g_CMBSInstance.u16_TargetVersion = u16_Version;
+
+   if(u16_Version & 0xF000)
+   {
+        CFR_DBG_OUT( "TARGET API version: %x.%02x.%x\n", (u16_Version>>12),((u16_Version & 0xFF0)>>4), (u16_Version & 0xF) );
+   }
+   else
+   {
+        CFR_DBG_OUT( "TARGET API version: %02x.%02x\n", (u16_Version>>8),(u16_Version &0xFF) );
+   }
+   
+   cfr_ie_dser_u16 (pu8_Buffer+2, &u16_Version );
+   g_CMBSInstance.u16_TargetBuild   = u16_Version;
+   CFR_DBG_OUT( "TARGET BUILD      : %02x.%02x\n", (u16_Version>>8),(u16_Version &0xFF) );
+
+   CFR_DBG_OUT( "TARGET mode       : %d\n", pu8_Buffer[5] );
+   
+    if ( g_CMBSInstance.u16_TargetVersion == 0x0001 )
+    {   
+        // bootloader does not support checksum
+        g_st_CMBSCapabilities.u8_Checksum = 0;
+    }
+    
+   _cmbs_int_StartupBlockSignal( &g_CMBSInstance );
+#endif
+}
+
+//		========== cmbs_int_cmd_FlowNOK ===========
+/*!
+		\brief				 destination side signal that it's not able to receive any packets.
+                         stop transmission for destination.
+
+		\param[in,out]		 pu8_Buffer    pointer to paramete, e.g. last received packet number
+
+		\return				 <none>
+
+*/
+
+void  _cmbs_int_cmd_FlowNOK ( u8 * pu8_Buffer )
+{
+   u16 u16_Packet;
+
+   cfr_ie_dser_u16 (pu8_Buffer, &u16_Packet );
+   g_CMBSInstance.e_DestFlowState = E_CMBS_FLOW_STATE_STOP;
+#if !defined ( CMBS_TARGET_API )
+   CFR_DBG_WARN( "CMBS-API: Target side is busy, can't receive any more packets\n" );
+#endif
+}
+
+//		========== cmbs_int_cmd_FlowRestart ===========
+/*!
+		\brief				 destination side signal that it's able to receive packets.
+                         enable transmission for destination.
+
+		\param[in,out]		 pu8_Buffer    pointer to paramete, e.g. last received packet number
+
+		\return				 <none>
+
+*/
+
+void  _cmbs_int_cmd_FlowRestart ( u8 * pu8_Buffer )
+{
+   u16 u16_Packet;
+
+   cfr_ie_dser_u16 (pu8_Buffer, &u16_Packet );
+   g_CMBSInstance.e_DestFlowState = E_CMBS_FLOW_STATE_GO;
+#if !defined ( CMBS_TARGET_API )
+   CFR_DBG_WARN( "CMBS-API: Target side is free, can receive packets again\n" );
+#endif
+}
+
+//		========== cmbs_int_cmd_Dispatcher ===========
+/*!
+		\brief				 dispatch internal CMBS commands
+
+		\param[in]		 u8_Cmd		 internal CMBS Command ID
+
+		\param[in]		 pu8_Buffer	 pointer to parameter
+
+		\param[in]		 u16_Size	 size of parameter
+
+		\return			<none>
+
+*/
+
+void  cmbs_int_cmd_Dispatcher( u8 u8_Cmd, u8 * pu8_Buffer, u16 u16_Size )
+{
+   if( u16_Size ){}   // unused u16_Size; eliminate "unused parameter" compiler warning
+
+   switch ( u8_Cmd )
+   {
+#if defined ( CMBS_API_TARGET )
+      // start up command of host to target
+      case CMBS_CMD_HELLO:
+         /// Hello buffer configure also the IOM channel
+         if ( u16_Size )
+            _cmbs_int_cmd_Hello( pu8_Buffer, u16_Size );
+         else
+            _cmbs_int_cmd_Hello( NULL, 0 );
+
+ 
+        // preset with 0, maybe a different host now.
+        g_st_CMBSCapabilities.u8_Checksum = 0;
+
+        break;
+	 case CMBS_CMD_FLASH_START_RES:
+	 	  p_cmbs14_SuspendTxRes( 1 );
+	 	 break;
+		 
+	 case CMBS_CMD_FLASH_STOP_RES:
+	 	  p_cmbs14_ResumeTxRes( 1 );
+		 break;
+
+        // checksum command of host to target
+     case CMBS_CMD_CAPABILITIES:
+         /// Capabilities buffer configure also the IOM channel
+         if ( u16_Size )
+             _cmbs_int_cmd_Capabilities(pu8_Buffer);
+         else
+             _cmbs_int_cmd_Capabilities(NULL);
+
+         // send own Capabilities in a reply message
+         cmbs_int_cmd_SendCapablitiesReply();
+
+        break;
+        // checksum command of host to target
+     case CMBS_CMD_STORE_RAM_DUMP:
+         /// To Forcefully reset the CMBS to capture the RAM Dump
+         _cmbs_int_cmd_StoreRAMDump();
+        break;
+
+#endif
+#if !defined ( CMBS_API_TARGET )
+      // start up reply command from target to host
+      case CMBS_CMD_HELLO_RPLY:
+         _cmbs_int_cmd_HelloRply( pu8_Buffer );
+         break;
+	  case CMBS_CMD_FLASH_START_REQ:
+		  _cmbs_int_SuspendTxCommands();
+		  break;
+	  case CMBS_CMD_FLASH_STOP_REQ:
+		  _cmbs_int_ResumeTxCommands();
+		  break;
+        // capabilities reply command from target to host
+      case CMBS_CMD_CAPABILITIES_RPLY:
+          _cmbs_int_cmd_CapabilitiesReply(pu8_Buffer);
+          break;
+	  case CMBS_CMD_SEND_OPUS_PAYLOAD:
+		  _cmbs_int_cmd_SendOPUSPayload();
+		  break;
+#endif
+
+      case CMBS_CMD_FLOW_NOK:
+      // destination side is busy and not able to receive any more packets
+      _cmbs_int_cmd_FlowNOK( pu8_Buffer );
+        break;
+
+      case CMBS_CMD_FLOW_RESTART:
+      // destination side is free and restart to receive packets
+      _cmbs_int_cmd_FlowRestart(pu8_Buffer );
+        break;
+
+      case CMBS_CMD_RESET:
+      _cmbs_int_cmd_Reset();
+         break;
+
+      default:
+         CFR_DBG_WARN( "ProtCMD Dispatcher: %d is not implemented, yet!\n", u8_Cmd );
+   }
+}
+
+
+u32 cmbs_cmd_parser( CMBS_CMD id, u8* pu8_Buffer, u8* pu8_Buffer_parse, u32 u32_Pos)	
+{
+	switch ( id )
+	{
+		case CMBS_CMD_HELLO:		
+			// byte 0 = TDM config
+			switch(pu8_Buffer[0])
+				{
+					case CMBS_TDM_TYPE_MASTER: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n TDM config = %s ", "CMBS_TDM_TYPE_MASTER");
+					break;
+					case CMBS_TDM_TYPE_SLAVE: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n TDM config = %s ", "CMBS_TDM_TYPE_SLAVE");
+					break;
+					case CMBS_TDM_TYPE_MASTER_LOOP: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n TDM config = %s ", "CMBS_TDM_TYPE_MASTER_LOOP");
+					break;
+					case CMBS_TDM_TYPE_SLAVE_LOOP: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n TDM config = %s ", "CMBS_TDM_TYPE_SLAVE_LOOP");	
+					break;
+				}
+			// byte 1 = speed config
+			switch(pu8_Buffer[1])
+				{
+					case CMBS_TDM_PCM_512: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_PCM_512");
+					break;
+					case CMBS_TDM_PCM_768: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_PCM_768");
+					break;
+					case CMBS_TDM_PCM_1536: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_PCM_1536");
+					break;
+					case CMBS_TDM_PCM_2048: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_PCM_2048");	
+					break;
+					case CMBS_TDM_IOM_512: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_IOM_512");
+					break;
+					case CMBS_TDM_IOM_768: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_IOM_768");
+					break;
+					case CMBS_TDM_IOM_1536: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_IOM_1536");
+					break;
+					case CMBS_TDM_IOM_2048: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n speed config = %s ", "CMBS_TDM_IOM_2048");	
+					break;					
+				}
+			// byte 2 = sync config
+			switch(pu8_Buffer[2])
+				{
+					case CMBS_TDM_SYNC_SHORT_FR: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n sync config = %s ", "CMBS_TDM_SYNC_SHORT_FR");
+					break;
+					case CMBS_TDM_SYNC_SHORT_FF: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n sync config = %s ", "CMBS_TDM_SYNC_SHORT_FF");
+					break;
+					case CMBS_TDM_SYNC_SHORT_LF: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n sync config = %s ", "CMBS_TDM_SYNC_SHORT_LF");
+					break;
+					case CMBS_TDM_SYNC_LONG: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n sync config = %s ", "CMBS_TDM_SYNC_LONG");	
+					break;					
+				}
+
+			u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos), "\n SlotEnable =  0x%04x", (pu8_Buffer[4] << 8) | pu8_Buffer[3]);
+
+			switch(pu8_Buffer[5])
+				{
+					case CMBS_FLOW_CTRL_NONE: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n device type = %s ", "CMBS_FLOW_CTRL_NONE");
+					break;
+					case CMBS_FLOW_CTRL_XON_XOFF: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n device type = %s ", "CMBS_FLOW_CTRL_XON_XOFF");
+					break;
+					case CMBS_FLOW_CTRL_RTS_CTS: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n device type = %s ", "CMBS_FLOW_CTRL_RTS_CTS");
+					break;
+					case CMBS_FLOW_CTRL_DSR_DTR: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n device type = %s ", "CMBS_FLOW_CTRL_DSR_DTR");	
+					break;					
+				}
+		break;
+
+		case CMBS_CMD_HELLO_RPLY:
+			u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos), "\n CMBS_API_TARGET_VERSION = 0x%04x", (pu8_Buffer[1] << 8) | pu8_Buffer[0]);
+			u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos), "\n CMBS_TARGET_BUILD = 0x%04x ", (pu8_Buffer[3]<<8) | pu8_Buffer[2]);
+			switch(pu8_Buffer[4])
+				{
+					case CMBS_MODE_MLB: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n mode = %s ", "CMBS_MODE_MLB");
+					break;
+					case CMBS_MODE_AMLB: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n mode = %s ", "CMBS_MODE_AMLB");
+					break;
+					case CMBS_MODE_DECT_PIPE: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n mode = %s ", "CMBS_MODE_DECT_PIPE");
+					break;
+					case CMBS_MODE_DECT_MAC_PIPE: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n mode = %s ", "CMBS_MODE_DECT_MAC_PIPE");	
+					break;					
+					case CMBS_MODE_MAX: u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n mode = %s ", "CMBS_MODE_MAX");	
+					break;					
+				}
+		break;
+
+		
+		case CMBS_CMD_CAPABILITIES:
+		case CMBS_CMD_CAPABILITIES_RPLY:
+			if(pu8_Buffer[4] & 1)
+				{
+					u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n  %s ", "CHECKSUM_SUPPORT");
+				}
+				else
+				{
+					u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos),"\n  %s ", "CHECKSUM_NOT_SUPPORT");
+				}
+					
+		break;
+
+		case CMBS_CMD_FLOW_NOK:
+		case CMBS_CMD_FLOW_RESTART:		
+			u32_Pos+=sprintf((char*)(pu8_Buffer_parse+u32_Pos), "\n packet = 0x%04x", (pu8_Buffer[0] << 8) | pu8_Buffer[1]);
+		break;		
+
+		case CMBS_CMD_FLASH_START_RES:
+		case CMBS_CMD_FLASH_STOP_RES:	
+		case CMBS_CMD_FLASH_START_REQ:
+		case CMBS_CMD_FLASH_STOP_REQ:
+		case CMBS_CMD_RESET:
+		case CMBS_CMD_STORE_RAM_DUMP:
+		case CMBS_CMD_SEND_OPUS_PAYLOAD:
+	 	break;	
+	 	
+	}
+	return u32_Pos	        ;
+}
+
+//		========== cmbs_int_cmd_FlowNOKHandle  ===========
+/*!
+		\brief				 send information to other side to stop transmission
+
+		\param[in,out]		 void
+
+		\return				< none >
+
+*/
+
+void  cmbs_int_cmd_FlowNOKHandle ( u16 u16_Packet )
+{
+   u8 u8_Buffer[2];
+
+   if ( g_CMBSInstance.e_OrigFlowState == E_CMBS_FLOW_STATE_GO )
+   {
+      g_CMBSInstance.e_OrigFlowState = E_CMBS_FLOW_STATE_STOP;
+
+      cfr_ie_ser_u16 ( u8_Buffer, u16_Packet );
+
+      cmbs_int_cmd_Send( (u8)CMBS_CMD_FLOW_NOK, u8_Buffer, sizeof(u8_Buffer) );
+
+   }
+
+}
+
+//		========== cmbs_int_cmd_FlowRestartHandle  ===========
+/*!
+		\brief				 send information to other side to re-enable transmission
+
+		\param[in,out]		 void
+
+		\return				void     cmbs_int_cmdFlowStop			 description
+
+*/
+
+void  cmbs_int_cmd_FlowRestartHandle ( u16 u16_Packet )
+{
+   u8 u8_Buffer[2];
+
+   if ( g_CMBSInstance.e_OrigFlowState == E_CMBS_FLOW_STATE_STOP )
+   {
+      g_CMBSInstance.e_OrigFlowState = E_CMBS_FLOW_STATE_GO;
+      cfr_ie_ser_u16 ( u8_Buffer, u16_Packet );
+
+      cmbs_int_cmd_Send( (u8)CMBS_CMD_FLOW_RESTART, u8_Buffer, sizeof(u8_Buffer) );
+   }
+}
+
+void  cmbs_int_cmd_ReceiveEarly ( u8 * pu8_Buffer )
+{
+   PST_CMBS_SER_MSG p_Mssg = (PST_CMBS_SER_MSG)pu8_Buffer;
+//   int i;
+
+//   CFR_DBG_OUT ( "CMBS-API: message Early Receive\n" );
+//   CFR_DBG_OUT ( "CMBS-API: packet => ");
+// 	for ( i=0; i < 6; i++ )
+// 		CFR_DBG_OUT ( "%02x ", pu8_Buffer[i] );
+// 	CFR_DBG_OUT ( "\n" );
+
+  if ( (p_Mssg->st_MsgHdr.u16_EventID & CMBS_CMD_MASK) == CMBS_CMD_MASK)
+  {
+//      cmbs_dbg_CmdTrace ( pu8_Buffer, 0 );
+
+      cmbs_int_cmd_Dispatcher( (u8)p_Mssg->st_MsgHdr.u16_EventID, (u8*)p_Mssg->u8_Param, 0 );
+  }
+}
+
+u8    cmbs_int_cmd_FlowStateGet ( void )
+{
+   return (u8)g_CMBSInstance.e_DestFlowState;
+}
+//		========== _cmbs_int_cmd_Capabilities ===========
+/*!
+        \brief				 Capabilities of the Host received, e.g. checksum.
+
+        \param[in,out]		 pu8_Buffer		 pointer to buffer, currently NULL
+
+        \return				 < none >
+
+*/
+
+void              _cmbs_int_cmd_Capabilities(u8 *pu8_Buffer)
+{
+#if defined ( CMBS_API_TARGET )
+    // u8 u8_Buffer[5];
+    if ( pu8_Buffer )
+    {
+        // Curretnyl 4 Bytes of capabilities are sent, but it could be extented for future use
+        // first byte is the length.
+        if ( pu8_Buffer[4] & CMBS_CAPABILITY_MASK )
+        {
+            // currently the only supported capability
+            // Store this capability
+            g_st_CMBSCapabilities.u8_Checksum = 1;
+        }
+        else
+        {
+            g_st_CMBSCapabilities.u8_Checksum = 0;
+        }
+    }
+#endif // CMBS_API_TARGET
+
+  if( pu8_Buffer ){}   // pu8_Buffer irrelevat here; eliminate "unused parameter" compiler warning
+}
+
+//		========== _cmbs_int_cmd_SendOPUSPayload ===========
+/*!
+\brief				 Send OPUS Payload to Target, with checksum.
+
+\param[in,out]		 < none >
+
+\return				 < none >
+
+*/
+
+void cmbs_send_OPUSPayload(PST_CFR_IE_LIST p_List, u8 *pu8_OPUSData, u16 u16_OPUSData_Size)
+{
+#if !defined(CMBS_API_TARGET)
+	cmbs_api_ie_OPUSDataAdd(p_List, pu8_OPUSData, u16_OPUSData_Size);
+	cmbs_int_EventSend(CMBS_EV_DEM_OPUS_DATA, p_List->pu8_Buffer, p_List->u16_CurSize);
+#endif
+}
+
+#if !defined(CMBS_API_TARGET)
+u8 OPUS_30ms_buff[240];
+#ifdef DEBUG_UART_DATA_PIPE
+u8 u8_Init = 1;
+#endif
+#endif
+E_CMBS_RC _cmbs_int_cmd_SendOPUSPayload(void)
+{
+#if !defined(CMBS_API_TARGET)
+
+#ifndef DEBUG_UART_DATA_PIPE
+	static char *filename_stereo = "../feel_it_still.opus";
+	static FILE *fp = NULL;
+#endif
+
+	PST_CFR_IE_LIST p_List;
+	ST_IE_DATA		st_Data;
+	
+	
+	
+#ifndef DEBUG_UART_DATA_PIPE
+	if (fp == NULL) {
+		fp = fopen(filename_stereo, "rb");
+		if (fp)
+		{
+			char file_header[16];
+			fread(&file_header, 1, 16, fp);
+		}
+	}
+	memset(&OPUS_30ms_buff, 0x0 , 240);
+	if (fp)
+	{
+		char PKTheader[2];
+		fread(&PKTheader, 1, 2, fp);
+		fread(&OPUS_30ms_buff, 1, 76, fp);
+		fread(&PKTheader, 1, 2, fp);
+		fread(&OPUS_30ms_buff[76], 1, 76, fp);
+		fread(&PKTheader, 1, 2, fp);
+		fread(&OPUS_30ms_buff[152], 1, 76, fp);
+		//printf("We have read the '%d' bytes from file\n", ret);
+		if (feof(fp))
+		{
+			/* We have reached the end of the file, rewind and start again.... Infinite loop */
+			//printf("We have reached the end of the file\n");
+			fclose(fp);
+                        fp = NULL;
+		}
+	}
+	//else
+	{
+		//printf("We failed to open the file name '%s'\n", filename_stereo);
+	}
+#endif
+
+#ifdef DEBUG_UART_DATA_PIPE
+	if (u8_Init)
+	{
+		memset(&OPUS_30ms_buff[0], 'u', 76);
+		memset(&OPUS_30ms_buff[76], 'v', 76);
+		memset(&OPUS_30ms_buff[152], 'w', 76);
+		u8_Init = 0;
+	}
+	else
+	{
+		memset(&OPUS_30ms_buff[0], 'x', 76);
+		memset(&OPUS_30ms_buff[76], 'y', 76);
+		memset(&OPUS_30ms_buff[152], 'z', 76);
+		u8_Init = 1;
+	}
+#endif
+	ALLOCATE_IE_LIST(p_List);
+	st_Data.u16_DataLen = 228;
+	st_Data.pu8_Data = OPUS_30ms_buff;
+
+	cmbs_send_OPUSPayload(p_List, st_Data.pu8_Data, st_Data.u16_DataLen);
+	return CMBS_RC_OK;
+#else
+	return CMBS_RC_OK;
+#endif // CMBS_API_TARGET
+}
+
+//		========== _cmbs_int_cmd_CapabilitiesReply ===========
+/*!
+        \brief				 Capabilities of the Target received, e.g. checksum.
+
+        \param[in,out]		 pu8_Buffer		 pointer to buffer, currently NULL
+
+        \return				 < none >
+
+*/
+
+void _cmbs_int_cmd_CapabilitiesReply(u8 *pu8_Buffer)
+{
+#if !defined ( CMBS_API_TARGET )
+    if ( pu8_Buffer )
+    {
+        // Curretnyl 4 Bytes of capabilities are sent, but it could be extented for future use
+        // first byte is the length.
+        if ( pu8_Buffer[4] & CMBS_CAPABILITY_MASK )
+        {
+            // curretnlyx the only supported capability
+            // Store this capability
+            g_st_CMBSCapabilities.u8_Checksum = 1;
+            CFR_DBG_INFO("\n CHECKSUM_SET received\n");
+        }
+    }
+
+    // notify upper layer
+    _cmbs_int_StartupBlockSignal(&g_CMBSInstance);
+#endif // CMBS_API_TARGET
+
+  if( pu8_Buffer ){}   // pu8_Buffer irrelevat here; eliminate "unused parameter" compiler warning
+}
+
+//		========== _cmbs_int_cmd_StoreRAMDump ===========
+/*!
+        \brief				 To forcefully reset the CMBS to capture RAM Dump
+
+        \param[in,out]		 < none >
+
+        \return				 < none >
+*/
+
+void              _cmbs_int_cmd_StoreRAMDump(void)
+{
+#if defined ( CMBS_API_TARGET ) && defined ( CRASH_DUMP )
+	typedef void (*pfn_Crash)(void);
+	
+		{
+			pfn_Crash p_Crashfn;
+
+			p_Crashfn = (pfn_Crash)0xFFFFFFFF;
+			p_Crashfn();
+		}
+
+	
+	// wait for WD reset
+	while (1);
+#endif // CMBS_API_TARGET
+}
+
+//*/

dectmngr/src/cmbs/cmbs_dbg.h

@@ -0,0 +1,48 @@
+/*!
+*  \file       cmbs_dbg.h
+*  \brief      This file contains debug functions for CMBS API
+*  \author     andriig
+*
+*  @(#)  %filespec: cmbs_dbg.h~DMZD53#6 %
+*
+*******************************************************************************/
+
+#if   !defined( CMBS_DBG_H )
+#define  CMBS_DBG_H
+
+#include "cmbs_api.h"               /* CMBS API definition */
+#include "cmbs_han.h"
+
+const char* cmbs_dbg_GetEventName(E_CMBS_EVENT_ID id);
+const char* cmbs_dbg_GetCommandName(CMBS_CMD id);
+const char* cmbs_dbg_GetParamName(E_CMBS_PARAM e_ParamId);
+const char* cmbs_dbg_GetIEName(E_CMBS_IE_TYPE e_IE);
+const char* cmbs_dbg_GetHsTypeName(E_CMBS_HS_TYPE e_HsType);
+const char* cmbs_dbg_GetToneName(E_CMBS_TONE e_Tone);
+const char* cmbs_dbg_GetCallProgressName(E_CMBS_CALL_PROGRESS e_Prog);
+const char* cmbs_dbg_GetCallTypeName(E_CMBS_CALL_STATE_TYPE    e_CallType);
+const char* cmbs_dbg_GetCallStateName(E_CMBS_CALL_STATE_STATUS  e_CallStatus);
+E_CMBS_PARAM cmbs_dbg_String2E_CMBS_PARAM(const char *psz_Value);
+E_CMBS_TONE cmbs_dbg_String2E_CMBS_TONE(const char *psz_Value);
+E_CMBS_CALL_PROGRESS cmbs_dbg_String2E_CMBS_CALL_PROGR(const char *psz_Value);
+void    cmbs_dbg_DumpIEList(u8 *pu8_Buffer, u16 u16_Size);
+void    cmbs_dbg_CmdTrace(const char *message, ST_CMBS_SER_MSGHDR *pst_Hdr, u8 *pu8_Buffer);
+void	cmbs_dbg_getTimestampString(char *buffer);
+
+/* Parse IE Function */
+typedef u32 (*pfn_cmbs_dbg_ParseIEFunc)(char *pOutput, u32 u32_OutputSize, void *pv_IE, u16 u16_IE);
+void cmbs_dbg_SetParseIEFunc(pfn_cmbs_dbg_ParseIEFunc); 
+
+typedef enum
+{
+    CMBS_LOG_OUTPUT_TERMINAL = 0x0,
+    CMBS_LOG_OUTPUT_LOGFILE, 
+    CMBS_LOG_OUTPUT_BOTH, 
+    CMBS_LOG_OUTPUT_NONE, 
+
+    CMBS_LOG_OUTPUT_MAX
+}E_CMBS_LOG_OUTPUT;
+
+#define	CMBS_MAX_IE_PRINT_SIZE		14000
+
+#endif

dectmngr/src/cmbs/cmbs_dcm.c

@@ -0,0 +1,35 @@
+/*!
+*	\file			cmbs_dcm.c
+*	\brief			API cakk media functions
+*	\Author			CMBS Team 
+*
+*	@(#)	%filespec: cmbs_dcm.c~DMZD53#7 %
+*
+*******************************************************************************/
+
+
+#include "cmbs_int.h"
+
+
+E_CMBS_RC cmbs_dcm_CallTransferRes(PST_IE_CALLTRANSFERREQ pst_TrfReq, PST_IE_RESPONSE pst_Resp)
+{
+	PST_CFR_IE_LIST p_List;
+	ALLOCATE_IE_LIST(p_List);
+
+	cmbs_api_ie_CallTransferReqAdd((void*)p_List, pst_TrfReq);
+    cmbs_api_ie_ResponseAdd((void*)p_List, pst_Resp);
+
+	return cmbs_int_EventSend( CMBS_EV_DCM_CALL_TRANSFER_RES, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC cmbs_dcm_CallConferenceRes(PST_IE_CALLTRANSFERREQ pst_TrfReq, PST_IE_RESPONSE pst_Resp)
+{
+	PST_CFR_IE_LIST p_List;
+	ALLOCATE_IE_LIST(p_List);
+		cmbs_api_ie_CallTransferReqAdd((void*)p_List, pst_TrfReq);
+    cmbs_api_ie_ResponseAdd((void*)p_List, pst_Resp);
+
+
+	return cmbs_int_EventSend( CMBS_EV_DCM_CALL_CONFERENCE_RES, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+

dectmngr/src/cmbs/cmbs_dee.c

@@ -0,0 +1,299 @@
+/*!
+*	\file			cmbs_dee.c
+*	\brief		DEE (external endpoint) functions			
+*	\Author		stein 
+*
+*	@(#)	%filespec: cmbs_dee.c~DMZD53#9 %
+*
+*******************************************************************************/
+
+#if defined(__arm)
+# include "tclib.h"
+# include "embedded.h"
+#else
+# include <stdlib.h>
+# include <stdio.h>
+# include <string.h>
+#endif
+
+#include "cmbs_int.h"
+typedef enum
+{
+  FXS_EV_UNDEF,
+  FXS_EV_OFFHOOK, /*!<  OffHook event       */
+  FXS_EV_ONHOOK,  /*!<  OnHook event        */
+  FXS_EV_KEYPAD,  /*!<  Keypad event        */
+  FXS_EV_OFFHOOK_INT, /* Off hook to make inter com call (call class)*/
+  FXS_EV_OFFHOOK_EXT, /* Off hook to make External call (call class)*/
+  FXS_EV_PARL_EXT_CALL,
+  FXS_EV_PARL_INT_CALL,
+  FXS_EV_CW_ACCEPT,
+  FXS_EV_CALL_HOLD,
+  FXS_EV_CALL_RESUME,
+  FXS_EV_CALL_TRFR,
+  FXS_EV_CALL_CONF,
+  FXS_EV_CALL_RELEASE,
+  FXS_EV_CALL_TOGGLE,
+  FXS_EV_HOST_CONFIG,
+  FXS_EV_REG_FXS,
+  FXS_EV_MAX
+} FXS_EV;
+
+typedef enum
+{
+    E_TAPP_AUD_CHANNEL_MODE_UNDEF,          /*!< channel is not used */
+    E_TAPP_AUD_CHANNEL_MODE_PCM_16_NB,      /*!< channel is used as PCM 16 bit linear narrow-band 8 KHz*/
+    E_TAPP_AUD_CHANNEL_MODE_PCM_16_WB,      /*!< channel is used as PCM 16 bit linear wide-band 16 KHz  */
+    E_TAPP_AUD_CHANNEL_MODE_PCM_8_ALAW,     /*!< channel is used as PCM 8 bit a-law 8 KHz */
+    E_TAPP_AUD_CHANNEL_MODE_PCM_8_ULAW,     /*!< channel is used as PCM 8 bit u-law 8 KHz */
+    E_TAPP_AUD_CHANNEL_MODE_PCM_8,          /*!< channel is used as PCM 8 bit linear 8 KHz */
+    E_TAPP_AUD_CHANNEL_MODE_WB_16_ALAW,     /*!< channel is used as PCM 8 bit a-law 16 KHz */
+    E_TAPP_AUD_CHANNEL_MODE_WB_16_ULAW,		/*!< channel is used as PCM 8 bit u-law 16 KHz */
+    E_TAPP_AUD_CHANNEL_MODE_MAX             /*!< channel mode max definition */
+} E_TAPP_AUD_CHANNEL_MODE;
+
+u32	cmbs_dee_CallInstanceNew( void * pv_AppRefHandle )
+{
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return ++g_CMBSInstance.u32_CallInstanceCount;
+}
+
+E_CMBS_RC	cmbs_dee_CallEstablish( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_ESTABLISH, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+E_CMBS_RC	cmbs_dee_ReconnectCallSwitch( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_RECON_CALL_SWITCH, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+E_CMBS_RC	cmbs_dee_CallProgress( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_PROGRESS, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallAnswer( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_ANSWER, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallRelease( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_RELEASE, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallReleaseComplete( void * pv_AppRefHandle, u32 u32_CallInstance )
+{
+	PST_CFR_IE_LIST p_List = cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	cmbs_api_ie_CallInstanceAdd( p_List, u32_CallInstance );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_RELEASECOMPLETE, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallInbandInfo(void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_INBANDINFO, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallMediaOffer( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_MEDIA_OFFER, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallMediaOfferRes( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_MEDIA_OFFER_RES, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_HsCodecCfmFailed( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_HS_CODEC_CFM_FAILED, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC	cmbs_dee_CallHold( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_HOLD, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallResume( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_RESUME, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallHoldRes( void * pv_AppRefHandle, u32 u32_CallInstance, u16 u16_HsNum, E_CMBS_RESPONSE e_Response )
+{
+	ST_IE_RESPONSE   st_Response;
+	PST_CFR_IE_LIST  pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+	ALLOCATE_IE_LIST(pv_RefIEList);
+
+	st_Response.e_Response = e_Response;
+
+	// Add call Instance IE
+	cmbs_api_ie_CallInstanceAdd( (void*)pv_RefIEList, u32_CallInstance );
+	cmbs_api_ie_ResponseAdd( (void*)pv_RefIEList, &st_Response );
+	cmbs_api_ie_HandsetsAdd( (void*)pv_RefIEList, u16_HsNum);
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_HOLD_RES, pv_RefIEList->pu8_Buffer, pv_RefIEList->u16_CurSize );
+}
+
+E_CMBS_RC	cmbs_dee_CallResumeRes( void * pv_AppRefHandle, u32 u32_CallInstance, u16 u16_HsNum, E_CMBS_RESPONSE e_Response )
+{
+	ST_IE_RESPONSE   st_Response;
+	PST_CFR_IE_LIST  pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+	ALLOCATE_IE_LIST(pv_RefIEList);
+
+	st_Response.e_Response = e_Response;
+
+	// Add call Instance IE
+	cmbs_api_ie_CallInstanceAdd( (void*)pv_RefIEList, u32_CallInstance );
+	cmbs_api_ie_ResponseAdd( (void*)pv_RefIEList, &st_Response );
+	cmbs_api_ie_HandsetsAdd( (void*)pv_RefIEList, u16_HsNum);
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_RESUME_RES, pv_RefIEList->pu8_Buffer, pv_RefIEList->u16_CurSize );
+}
+
+E_CMBS_RC	cmbs_dee_HandsetLinkRelease(u8 Handset)
+{
+	PST_CFR_IE_LIST  pv_RefIEList;
+
+	ALLOCATE_IE_LIST(pv_RefIEList);
+
+	cmbs_api_ie_HsNumberAdd((void*)pv_RefIEList, Handset);
+	return cmbs_int_EventSend( CMBS_EV_DEE_HANDSET_LINK_RELEASE , pv_RefIEList->pu8_Buffer, pv_RefIEList->u16_CurSize );
+}
+
+E_CMBS_RC	cmbs_dee_MergeCalls( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_MERGE_CALLS, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+E_CMBS_RC	cmbs_dee_AnsFxsCall( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend(CMBS_EV_DEE_ANS_FXS_CALL, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_MakeSPKOgCall( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend(CMBS_EV_DEE_SPK_OG_CALL, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+
+E_CMBS_RC	cmbs_dee_EmergencyCallRelease( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_EMERGENCY_RELEASE, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dee_CallScreening( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_SCREENING, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+E_CMBS_RC	cmbs_dee_CallDeflection( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_DEFLECTION, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+E_CMBS_RC	cmbs_dee_CallDeflectionRes( void * pv_AppRefHandle, u32 u32_CallInstance, u16 u16_HsNum, E_CMBS_RESPONSE e_Response )
+{
+	ST_IE_RESPONSE   st_Response;
+	PST_CFR_IE_LIST  pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+	ALLOCATE_IE_LIST(pv_RefIEList);
+
+	st_Response.e_Response = e_Response;
+
+	// Add call Instance IE
+	cmbs_api_ie_CallInstanceAdd( (void*)pv_RefIEList, u32_CallInstance );
+	cmbs_api_ie_ResponseAdd( (void*)pv_RefIEList, &st_Response );
+	cmbs_api_ie_HandsetsAdd( (void*)pv_RefIEList, u16_HsNum);
+
+	return cmbs_int_EventSend( CMBS_EV_DEE_CALL_DEFLECTION_RES, pv_RefIEList->pu8_Buffer, pv_RefIEList->u16_CurSize );
+}
+
+
+
+//*/

dectmngr/src/cmbs/cmbs_dem.c

@@ -0,0 +1,100 @@
+/*!
+*	\file		cmbs_dem.c
+*	\brief		DEM (external media) functions	
+*	\Author		stein 
+*
+*	@(#)	%filespec: cmbs_dem.c~DMZD53#4 %
+*
+*******************************************************************************/
+
+#if defined(__arm)
+# include "tclib.h"
+# include "embedded.h"
+#else
+# include <stdlib.h>
+# include <stdio.h>
+# include <string.h>
+#endif
+
+#include "cmbs_int.h"
+#include "cfr_ie.h"
+#include "cfr_debug.h"
+
+E_CMBS_RC	cmbs_dem_ChannelStart( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEM_CHANNEL_START, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dem_ChannelStop( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEM_CHANNEL_STOP, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dem_ChannelInternalConnect( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEM_CHANNEL_INTERNAL_CONNECT, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dem_ToneStart( void *pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEM_TONE_START, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+
+E_CMBS_RC	cmbs_dem_ToneStop( void *pv_AppRefHandle, void * pv_RefIEList )
+{
+	PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	return cmbs_int_EventSend( CMBS_EV_DEM_TONE_STOP, p_List->pu8_Buffer, p_List->u16_CurSize );  
+}
+
+E_CMBS_RC	cmbs_dem_TDMLoopbackStart( void *pv_AppRefHandle, void * pv_RefIEList )
+{
+    PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+
+    return cmbs_int_EventSend( CMBS_EV_DEM_TDM_LOOPBACK_START, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC	cmbs_dem_TDMLoopbackStop( void *pv_AppRefHandle, void * pv_RefIEList )
+{
+    PST_CFR_IE_LIST p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+
+    return cmbs_int_EventSend( CMBS_EV_DEM_TDM_LOOPBACK_STOP, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC cmbs_dem_ConfigTDMSlots(void *pv_AppRefHandle, u32 u32_TDMSlots)
+{
+	PST_CFR_IE_LIST p_List;
+
+	UNUSED_PARAMETER( pv_AppRefHandle );
+
+	ALLOCATE_IE_LIST(p_List);
+
+	cmbs_api_ie_TDMSlotsAdd( (void*)p_List, u32_TDMSlots );
+
+	return cmbs_int_EventSend( CMBS_EV_DEM_CONFIG_TDM_SLOTS, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+//*/

dectmngr/src/cmbs/cmbs_fifo.c

@@ -0,0 +1,224 @@
+/*!
+*  \file       cmbs_fifo.c
+*  \brief      Fifo message queue for CMBS host and CMBS target
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================\n
+*  date        name     version   action                                      \n
+*  ---------------------------------------------------------------------------\n
+*
+*******************************************************************************/
+
+#include "cmbs_api.h"
+#include "cmbs_int.h"
+#include "cfr_ie.h"
+#include "cfr_debug.h"
+#include "cmbs_fifo.h"
+#include "cfr_mssg.h"
+
+#if defined(CMBS_API_TARGET)
+#include "cg0type.h"
+#include "csys0reg.h"
+#include "cos00int.h"				 // Needed for critical section
+
+#if defined (CSS)
+#include "plicu.h"
+#include "priorities.h"
+#endif
+
+#endif
+
+#if defined( __linux__ )
+#include <stdio.h>
+#include <string.h>
+#endif
+
+
+
+
+
+
+// Brief
+//------------
+// Init the FIFO
+void              cmbs_util_FifoInit(ST_CMBS_FIFO *p_Fifo,
+                                     void *pv_Buffer,
+                                     const u16 u16_ElementSize,
+                                     const u16 u16_Size,
+                                     CFR_CMBS_CRITICALSECTION p_cSection)
+{
+	//printf("cmbs_util_FifoInit-->\n");
+    p_Fifo->u16_Count    = 0;
+    p_Fifo->u16_ElemSize = u16_ElementSize;
+
+    p_Fifo->p_Read  = p_Fifo->p_Write = pv_Buffer;
+    p_Fifo->u16_Size = p_Fifo->u16_Read2End = p_Fifo->u16_Write2End = u16_Size;
+	p_Fifo->p_cSection = p_cSection;
+
+	//init statistics
+	p_Fifo->s_fifo_statistics.u32_MaxInUse = 0;
+	p_Fifo->s_fifo_statistics.u32_CountFIFOIsFull= 0;
+	
+	CFR_CMBS_INIT_CRITICALSECTION ( p_Fifo->p_cSection );
+}
+
+
+// Brief
+//------------
+// Push a message to FIFO
+u8                cmbs_util_FifoPush(ST_CMBS_FIFO *p_Fifo, void *pv_Element)
+{
+    u16             u16_Write2End;
+    u8 *p_Write;
+
+	//printf("cmbs_util_FifoPush-->\n");
+
+	CFR_CMBS_ENTER_CRITICALSECTION ( p_Fifo->p_cSection );
+
+    if ( p_Fifo->u16_Count >= p_Fifo->u16_Size )
+    {
+    	p_Fifo->s_fifo_statistics.u32_CountFIFOIsFull++;
+		p_Fifo->s_fifo_statistics.u32_MaxInUse = 0;
+		CFR_CMBS_LEAVE_CRITICALSECTION ( p_Fifo->p_cSection );
+
+		CFR_DBG_WARN("cmbs_util_FifoPush: FIFO full\n");
+
+		return 0;
+    }
+
+    p_Write = p_Fifo->p_Write;
+
+    memcpy(p_Write, pv_Element, p_Fifo->u16_ElemSize);
+
+    p_Write += p_Fifo->u16_ElemSize;
+
+    u16_Write2End = p_Fifo->u16_Write2End;
+
+    if ( --u16_Write2End == 0 )
+    {
+        u16_Write2End = p_Fifo->u16_Size;
+        p_Write -= u16_Write2End * p_Fifo->u16_ElemSize;
+    }
+
+    p_Fifo->u16_Write2End = u16_Write2End;
+    p_Fifo->p_Write = p_Write;
+
+	p_Fifo->u16_Count++;
+
+	if(p_Fifo->u16_Count > p_Fifo->s_fifo_statistics.u32_MaxInUse)
+	{
+		p_Fifo->s_fifo_statistics.u32_MaxInUse = p_Fifo->u16_Count;
+	}
+	
+	CFR_CMBS_LEAVE_CRITICALSECTION ( p_Fifo->p_cSection );
+
+    return 1;
+}
+
+
+// Brief
+//------------
+// Get a message from FIFO
+void*            cmbs_util_FifoGet(ST_CMBS_FIFO *p_Fifo)
+{
+	//printf("cmbs_util_FifoGet-->\n");
+
+	CFR_CMBS_ENTER_CRITICALSECTION ( p_Fifo->p_cSection );
+
+    if ( p_Fifo->u16_Count == 0 )
+    {
+        //      CFR_DBG_WARN( "cmbs_util_FifoGet: FIFO empty\n" );
+		CFR_CMBS_LEAVE_CRITICALSECTION ( p_Fifo->p_cSection );
+        return NULL;
+    }
+
+
+	CFR_CMBS_LEAVE_CRITICALSECTION ( p_Fifo->p_cSection );
+
+    return p_Fifo->p_Read;
+}
+
+// Brief
+//------------
+// Pop (extract) a message from a FIFO
+void*            cmbs_util_FifoPop(ST_CMBS_FIFO *p_Fifo)
+{
+    u16             u16_Read2End;
+    u8 *p_Read;
+    void *p_Element;
+
+	//printf("cmbs_util_FifoPop-->\n");
+
+	CFR_CMBS_ENTER_CRITICALSECTION ( p_Fifo->p_cSection );
+
+    if ( p_Fifo->u16_Count == 0 )
+    {
+        CFR_DBG_WARN( "cmbs_util_FifoGet: FIFO empty\n" );
+		CFR_CMBS_LEAVE_CRITICALSECTION ( p_Fifo->p_cSection );
+        return NULL;
+    }
+
+    u16_Read2End = p_Fifo->u16_Read2End;
+    p_Read      = p_Fifo->p_Read;
+    p_Element   = p_Read;
+
+    p_Read += p_Fifo->u16_ElemSize;
+
+    if ( --u16_Read2End == 0 )
+    {
+        u16_Read2End = p_Fifo->u16_Size;
+        p_Read -= u16_Read2End * p_Fifo->u16_ElemSize;
+    }
+
+    p_Fifo->p_Read = p_Read;
+    p_Fifo->u16_Read2End = u16_Read2End;
+
+    p_Fifo->u16_Count--;
+
+	CFR_CMBS_LEAVE_CRITICALSECTION ( p_Fifo->p_cSection );
+
+    return p_Element;
+}
+
+// Brief
+//------------
+// Pop all messages from a FIFO. Return no. of popped messages
+u16  cmbs_util_FifoClear(ST_CMBS_FIFO *p_Fifo)
+{
+	u16	u16_count=0;
+
+	while (cmbs_util_FifoPop(p_Fifo))	// pop untill return NULL
+	{
+		u16_count++;
+	}
+	return u16_count;
+}
+
+void  cmbs_util_FifoPrintStatistics(ST_CMBS_FIFO* p_Fifo)
+{
+	CFR_CMBS_ENTER_CRITICALSECTION(p_Fifo->p_cSection);
+	
+	printf("\n\tCurrent use in fifo: %d",p_Fifo->u16_Count);
+	printf("\n\tMax use in fifo:     %d",p_Fifo->s_fifo_statistics.u32_MaxInUse);
+	printf("\n\tCount of full fifo:  %d\n\n",p_Fifo->s_fifo_statistics.u32_CountFIFOIsFull);
+
+	CFR_CMBS_LEAVE_CRITICALSECTION(p_Fifo->p_cSection);
+	
+}
+
+
+u16 cmbs_util_FifoCount(ST_CMBS_FIFO *p_Fifo)
+{
+
+    u16 u16_count;
+
+    CFR_CMBS_ENTER_CRITICALSECTION(p_Fifo->p_cSection);
+
+    u16_count = p_Fifo->u16_Count;
+
+    CFR_CMBS_LEAVE_CRITICALSECTION(p_Fifo->p_cSection);
+
+    return u16_count;
+}
+/*[----------- End Of File -------------------------------------------------------------------------------------------------------------]*/

dectmngr/src/cmbs/cmbs_fifo.h

@@ -0,0 +1,85 @@
+/*!
+*  \file       cmbs_fifo.h
+*  \brief      Fifo message queue for CMBS host and CMBS target
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================\n
+*  date        name     version   action                                          \n
+*  ----------------------------------------------------------------------------\n
+*
+*******************************************************************************/
+
+#if   !defined( CMBS_FIFO_H )
+#define  CMBS_FIFO_H
+#include "cmbs_int.h"
+#include "cfr_mssg.h"
+
+#if (VDSW_FEATURES & VDSW_ENC_REPEATER)
+#define FIFO_NUM_ENTRIES SD09_MAX_NUM_SUB + SD09_MAX_SUB_CRFP
+#else
+#define FIFO_NUM_ENTRIES SD09_MAX_NUM_SUB
+#endif
+
+
+typedef struct
+{
+	u32 u32_MaxInUse;
+	u32 u32_CountFIFOIsFull;
+}
+t_st_Fifo_Statistics;
+
+
+/*! \brief simple FIFO definition */
+typedef struct
+{
+   u16            u16_Count;         // number of elements
+   u16            u16_Size;          // buffer size( max number of elements )
+   u16             u16_ElemSize;      // element size
+   void *         p_Read;           // read pointer
+   void *         p_Write;          // write pointer
+   u16             u16_Read2End;      // number of unused elements until fifo end
+   u16             u16_Write2End;     // number of unused elements until fifo end
+   CFR_CMBS_CRITICALSECTION p_cSection;	// Critical Section for the queue
+   t_st_Fifo_Statistics s_fifo_statistics; // statistics for queue
+} ST_CMBS_FIFO, * PST_CMBS_FIFO;
+
+
+
+
+
+
+#if defined( __cplusplus )
+extern "C"
+{
+#endif
+
+
+
+
+/*****************************************************************************
+ * Utilities
+ *****************************************************************************/
+
+void              cmbs_util_FifoInit( ST_CMBS_FIFO * p_Fifo,
+                                     void * pv_Buffer,
+                                     const u16 u16_ElementSize,
+                                     const u16 u16_Size,
+                                     CFR_CMBS_CRITICALSECTION p_cSection);
+
+u8                cmbs_util_FifoPush( ST_CMBS_FIFO * p_Fifo, void * pv_Element );
+void *            cmbs_util_FifoGet( ST_CMBS_FIFO * p_Fifo );
+void *            cmbs_util_FifoPop( ST_CMBS_FIFO * p_Fifo );
+u16		          cmbs_util_FifoClear( ST_CMBS_FIFO * p_Fifo );
+u16		          cmbs_util_FifoCount(ST_CMBS_FIFO *p_Fifo);
+void  cmbs_util_FifoPrintStatistics(ST_CMBS_FIFO* p_Fifo);
+
+
+
+
+#if defined( __cplusplus )
+}
+#endif
+
+#endif   // CMBS_FIFO_H
+

dectmngr/src/cmbs/cmbs_fun.h

@@ -0,0 +1,131 @@
+/*!
+*   \file       fun_util.h
+*   \brief      HAN FUN API
+*   \author     ULE BS Team
+*
+*
+*******************************************************************************/
+
+#if	!defined( _CMBS_FUN_H )
+#define	_CMBS_FUN_H
+
+#include "cmbs_api.h"
+
+/*Device Management Interface ID 
+====================================
+This interface is used for registering Devices and Units with their associated data
+such as Unit Type and the list of interfaces they are supporting.
+It is also used for discovering all device and units by a configuration application
+*/
+
+#define DEVICE_MGMT_INTERFACE_ID    0x0001
+
+/* Device Management Interface - Server */
+/* Attributes */
+#define DEVICE_MGMT_IF_SERVER_ATTR_ID_NUM_OF_DEVICES		   0x0001
+
+/* Commands */
+#define DEVICE_MGMT_IF_SERVER_CMD_ID_REGISTER_DEVICE    		0x0001
+#define FUN_IF_DEV_MNGT_CMD_REGISTER_DEVICE 				 	0x0001
+#define FUN_IF_DEV_MNGT_CMD_DEREGISTER_DEVICE		 			0x0002
+#define FUN_IF_DEV_MNGT_CMD_START_SESS_READ_REG_INFO			0x0003
+#define FUN_IF_DEV_MNGT_CMD_END_SESS_READ_REG_INFO	 			0x0004
+#define FUN_IF_DEV_MNGT_CMD_GET_ENTRIES				 			0x0005
+
+#define 	MAX_NUM_OF_OPTIONAL_INTERFACES_IN_UNIT				8
+#define 	MAX_NUM_OF_UNITS_IN_DEVICE								6
+
+/////////////////////////////////
+/////////	 Structs	/////////
+/////////////////////////////////
+typedef  struct
+{
+	u8			UnitId;
+	u16 		UnitType;
+	u16 		NumberOfOptionalInterfaces;
+	u16			OptionalInterfaces[MAX_NUM_OF_OPTIONAL_INTERFACES_IN_UNIT];
+} ST_FUN_UNIT_INFO;
+
+typedef  struct 
+{
+	u16							DeviceId;
+	u16							DeviceEMC;
+	u8							NumOfUnits;
+	ST_FUN_UNIT_INFO 			Units[MAX_NUM_OF_UNITS_IN_DEVICE];
+} ST_FUN_DEVICE_INFO, * PST_FUN_DEVICE_INFO; 
+
+#define CMBS_HAN_IE_FUN_DEVICE_INFO_SIZE			sizeof(ST_FUN_DEVICE_INFO)
+
+// TODO: store request id as cookie and remove constant value
+#define CMBS_HAN_FUN_REGISTRATION_REQ_ID			50
+
+///////////////////////////////////////////////////////////////////////////////
+// brief	Macro which defines a bitfield mask in u8/u16/u32 value
+//
+// param	FieldName		Variable prefix
+// 			Type 			u8, u16, u32
+//			BitOffset		The offset of the bitfield in the value 
+//			BitWidth		Number of bits in the bitfield
+///////////////////////////////////////////////////////////////////////////////
+#define DEFINE_BITFIELD( FieldName, Type, BitOffet, BitWidth )							\
+	enum																				\
+	{																					\
+		FieldName##_OFS			= (BitOffet),											\
+		FieldName##_WIDTH		= (BitWidth),											\
+		FieldName##_MASK		= (Type)((( (Type)1<<(BitWidth))-1) << (BitOffet)),		\
+	};
+
+
+#define GET_BITFIELD_VAL( Var, FieldName )												\
+	( ((Var) & FieldName##_MASK ) >> FieldName##_OFS )			
+
+
+#define SET_BITFIELD_VAL( Var, FieldName, NewValue )									\
+	( ((Var) & (~FieldName##_MASK)) | ((NewValue) << FieldName##_OFS) )
+
+
+typedef enum
+{
+	FUN_IF_DEV_MNGT_REG_RESP_UID_TYPE_NONE					= 0x0,
+	FUN_IF_DEV_MNGT_REG_RESP_UID_TYPE_IPUI						= 0x1,
+	FUN_IF_DEV_MNGT_REG_RESP_UID_TYPE_IEEE_MAC_48			= 0x2,
+	FUN_IF_DEV_MNGT_REG_RESP_UID_TYPE_URI						= 0x3,
+	
+}
+t_en_hanIf_DevMngt_Reg_Dev_UID_Type;
+
+typedef enum
+{
+	FUN_IF_DEV_MNGT_REG_RESP_DISCR_TYPE_NON_PROPRIETARY		= 0x0,
+	FUN_IF_DEV_MNGT_REG_RESP_DISCR_TYPE_PROPRIETARY			= 0x1,
+}
+t_en_hanIf_DevMngt_RegResp_DiscrType;
+
+#define FUN_IF_DEV_MNGT_UID_LENGTH_IPUI					5
+#define FUN_IF_DEV_MNGT_UID_LENGTH_IEEE_MAC_48			12
+
+#define OTA_BASE_DEVICE_ID									0
+#define OTA_BASE_UNIT_MANAGMENT_UNIT_ID 				0
+#define OTA_DST_UNIT_MANAGMENT_UNIT_ID  					0
+#define OTA_MSG_TYPE_COMMAND_RESPONSE					3
+#define OTA_ADDR_TYPE_INDIVIDUAL							0
+#define OTA_INTERFACE_TYPE_SERVER							1
+#define FUN_INTERFACE_DEVICE_MGNT						1
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+// Define bitfields for Device Managment interface													///
+//  							FieldName 							Type	BitOffet	BitWidth	///
+///////////////////////////////////////////////////////////////////////////////////////////////////////
+DEFINE_BITFIELD( FUN_IF_DEV_MNGT_REG_DISCRIMINATOR_TYPE,			u8,		7,			1 );
+DEFINE_BITFIELD( FUN_IF_DEV_MNGT_REG_DEV_UID_TYPE,					u8,		0,			7 );
+DEFINE_BITFIELD( FUN_IF_DEV_MNGT_REG_RES_DISCRIMINATOR_TYPE,		u16,	15,			1 );
+DEFINE_BITFIELD( FUN_IF_DEV_MNGT_REG_RES_DEVICE_ADDRESS,			u16,	0,			15);
+
+
+
+
+
+#endif	// _FUN_UTIL_H
+
+/**********************[End Of File]**********************************************************************************************************/

dectmngr/src/cmbs/cmbs_han.c

@@ -0,0 +1,809 @@
+/*!
+*	\file       cmbs_han.c
+*	\brief
+*	\Author		CMBS Team
+*
+*
+*******************************************************************************/
+#if defined(__arm)
+    #include "tclib.h"
+    #include "embedded.h"
+#else
+    #include <stdlib.h>
+    #include <stdio.h>
+    #include <string.h>
+#endif
+
+#include "cmbs_int.h"
+#include "cmbs_han_ie.h"
+
+E_CMBS_RC cmbs_dsr_han_mngr_Init(void *pv_AppRefHandle, ST_HAN_CONFIG * pst_HANConfig)
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	ST_IE_HAN_CONFIG   st_HanCfgIe;
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	st_HanCfgIe.st_HanCfg = *pst_HANConfig;
+	cmbs_api_ie_HanCfgAdd(p_List,&st_HanCfgIe);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MNGR_INIT,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_mngr_Start (void *pv_AppRefHandle)
+{
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MNGR_START,NULL, 0);  
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_ReadTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry, u8 IsBrief )
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_NumOfEntries,		CMBS_IE_HAN_NUM_OF_ENTRIES);
+	cmbs_api_ie_ShortValueAdd(p_List,u16_IndexOfFirstEntry,	CMBS_IE_HAN_INDEX_1ST_ENTRY);
+	cmbs_api_ie_ByteValueAdd(p_List, IsBrief ? CMBS_HAN_DEVICE_TABLE_ENTRY_TYPE_BRIEF : CMBS_HAN_DEVICE_TABLE_ENTRY_TYPE_EXTENDED,	CMBS_IE_HAN_TABLE_ENTRY_TYPE);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_READ_TABLE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_ReadExtendedDeviceTablePhase2 (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry)
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_NumOfEntries,		CMBS_IE_HAN_NUM_OF_ENTRIES);
+	cmbs_api_ie_ShortValueAdd(p_List,u16_IndexOfFirstEntry,	CMBS_IE_HAN_INDEX_1ST_ENTRY);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_READ_EXTENDED_TABLE_PHASE_2, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_ReadBlackListedDeviceTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry)
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_NumOfEntries,		CMBS_IE_HAN_NUM_OF_ENTRIES);
+	cmbs_api_ie_ShortValueAdd(p_List,u16_IndexOfFirstEntry,	CMBS_IE_HAN_INDEX_1ST_ENTRY);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_READ_BLACK_LIST_DEVICE_TABLE, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_WriteTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry, ST_HAN_DEVICE_ENTRY * pst_HANDeviceEntriesArray)
+{
+	PST_CFR_IE_LIST						p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(u16_NumOfEntries);
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	UNUSED_PARAMETER(u16_IndexOfFirstEntry);
+	UNUSED_PARAMETER(pst_HANDeviceEntriesArray);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_WRITE_TABLE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_bind_ReadTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_NumOfEntries,		CMBS_IE_HAN_NUM_OF_ENTRIES);
+	cmbs_api_ie_ShortValueAdd(p_List,u16_IndexOfFirstEntry,	CMBS_IE_HAN_INDEX_1ST_ENTRY);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_BIND_READ_TABLE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_bind_WriteTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry, ST_HAN_BIND_ENTRY * pst_HANBindEntriesArray)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	ST_IE_HAN_BIND_ENTRIES	stIe_Binds;
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	stIe_Binds.u16_NumOfEntries		= u16_NumOfEntries;
+	stIe_Binds.u16_StartEntryIndex	= u16_IndexOfFirstEntry;
+	stIe_Binds.pst_BindEntries		= pst_HANBindEntriesArray;
+	cmbs_api_ie_HANBindTableAdd(p_List,&stIe_Binds);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_BIND_WRITE_TABLE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_bind_AddEntry (void *pv_AppRefHandle, PST_HAN_BIND_ENTRY pst_HANBindEntry)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANBindEntryAdd(p_List, pst_HANBindEntry);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_BIND_ADD_ENTRY, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_bind_RemoveEntry (void *pv_AppRefHandle, PST_HAN_BIND_ENTRY pst_HANBindEntry)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANBindEntryAdd(p_List, pst_HANBindEntry);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_BIND_REMOVE_ENTRY ,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_bind_ClearTable (void *pv_AppRefHandle)
+{
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_BIND_CLEAR_TABLE, NULL, 0);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_group_ReadTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry, u16 u16_GroupId)
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANNumOfEntriesAdd(p_List, u16_NumOfEntries);
+	cmbs_api_ie_HANIndex1stEntryAdd(p_List, u16_IndexOfFirstEntry);
+	cmbs_api_ie_HANGroupIdAdd(p_List, u16_GroupId);
+		
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_READ_TABLE, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_group_ReadList (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry)
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_NumOfEntries,		CMBS_IE_HAN_NUM_OF_ENTRIES);
+	cmbs_api_ie_ShortValueAdd(p_List,u16_IndexOfFirstEntry,	CMBS_IE_HAN_INDEX_1ST_ENTRY);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_READ_LIST, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Broadcast_ReadChannelTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry)
+{
+	PST_CFR_IE_LIST    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_NumOfEntries,		CMBS_IE_HAN_NUM_OF_ENTRIES);
+	cmbs_api_ie_ShortValueAdd(p_List,u16_IndexOfFirstEntry,	CMBS_IE_HAN_INDEX_1ST_ENTRY);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_BROADCAST_READ_CHANNEL_TABLE, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_group_WriteTable (void *pv_AppRefHandle, u16 u16_NumOfEntries, u16 u16_IndexOfFirstEntry, ST_HAN_GROUP_TABLE_ENTRY * pst_HANGroupEntriesArray)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	ST_IE_HAN_GROUP_ENTRIES	stIe_Groups;
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	stIe_Groups.u16_NumOfEntries	= u16_NumOfEntries;
+	stIe_Groups.u16_StartEntryIndex	= u16_IndexOfFirstEntry;
+	stIe_Groups.pst_GroupEntries	= pst_HANGroupEntriesArray;
+	cmbs_api_ie_HANGroupTableAdd(p_List,&stIe_Groups);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_WRITE_TABLE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_group_CreateGroup  (void *pv_AppRefHandle, u8 u8_BroadcastChannelId)
+{
+	PST_CFR_IE_LIST				p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANBroadcastChannelIdAdd(p_List, u8_BroadcastChannelId);
+		
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_CREATE_GROUP, p_List->pu8_Buffer, p_List->u16_CurSize );  
+
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_group_RemoveGroup  (void *pv_AppRefHandle, u16 u16_GroupId )
+{
+	PST_CFR_IE_LIST				p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	
+	cmbs_api_ie_HANGroupIdAdd(p_List, u16_GroupId);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_REMOVE_GROUP, p_List->pu8_Buffer, p_List->u16_CurSize );  
+
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC  cmbs_dsr_han_group_AddDeviceToGroup  (void *pv_AppRefHandle, u16 u16_GroupId, u16 u16_DeviceId, u8 u8_UnitId )
+{
+	PST_CFR_IE_LIST				p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	
+	cmbs_api_ie_HANGroupIdAdd(p_List, u16_GroupId);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceId);
+	cmbs_api_ie_HANUnitIdAdd(p_List, u8_UnitId);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_ADD_DEVICE_TO_GROUP, p_List->pu8_Buffer, p_List->u16_CurSize );  
+
+}
+//////////////////////////////////////////////////////////////////////////
+E_CMBS_RC   cmbs_dsr_han_group_RemoveDeviceFromGroup   (void *pv_AppRefHandle, u16 u16_GroupId, u16 u16_DeviceId, u8 u8_UnitId )
+{
+	PST_CFR_IE_LIST				p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	
+	cmbs_api_ie_HANGroupIdAdd(p_List, u16_GroupId);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceId);
+	cmbs_api_ie_HANUnitIdAdd(p_List, u8_UnitId);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GROUP_REMOVE_DEVICE_FROM_GROUP, p_List->pu8_Buffer, p_List->u16_CurSize );  
+
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_msg_RecvRegister (void *pv_AppRefHandle, ST_HAN_MSG_REG_INFO * pst_HANMsgRegInfo)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HanMsgRegInfoAdd(p_List,pst_HANMsgRegInfo);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MSG_RECV_REGISTER,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_msg_RecvUnregister (void *pv_AppRefHandle, ST_HAN_MSG_REG_INFO * pst_HANMsgRegInfo)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HanMsgRegInfoAdd(p_List,pst_HANMsgRegInfo);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MSG_RECV_UNREGISTER,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_msg_SendTxRequest (void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MSG_SEND_TX_START_REQUEST,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_msg_SendTxEnd(void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MSG_SEND_TX_END_REQUEST,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_msg_Send (void *pv_AppRefHandle, u16 u16_RequestId, PST_IE_HAN_MSG_CTL pst_MsgCtrl, ST_IE_HAN_MSG * pst_HANMsg)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_RequestId, CMBS_IE_REQUEST_ID);
+	cmbs_api_ie_HANMsgAdd(p_List,pst_HANMsg);
+
+	cmbs_api_ie_HANMsgCtlAdd(p_List, pst_MsgCtrl );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MSG_SEND,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_raw_msg_Send (void *pv_AppRefHandle, u16 u16_RequestId, ST_IE_HAN_MSG_CTL* pst_MsgCtrl, ST_IE_DATA * pst_HANRawMsg, u16 u16_DeviceId) 
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_RequestId, CMBS_IE_REQUEST_ID);
+	cmbs_api_ie_DataAdd(p_List, pst_HANRawMsg);
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+
+	cmbs_api_ie_HANMsgCtlAdd(p_List, pst_MsgCtrl );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_RAW_MSG_SEND,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+E_CMBS_RC cmbs_dsr_han_ModificationULEPagingInterval(u16 u16_DeviceId, u32 u32_ULEPagingIntervalMs)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+	cmbs_api_ie_HanULEPagingIntervalAdd(p_List,u32_ULEPagingIntervalMs);
+	
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_MODIFICATION_ULE_PAGING_INTERVAL,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+E_CMBS_RC cmbs_dsr_han_NodeSetupAttemptsEnable(bool b_enable)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	if(b_enable)
+	{
+		cmbs_api_ie_HanNodeSetupAttemptsEnableAdd(p_List,CMBS_HAN_NODE_SETUP_ATTEMPTS_ENABLE);
+	}
+	else
+	{
+		cmbs_api_ie_HanNodeSetupAttemptsEnableAdd(p_List,CMBS_HAN_NODE_SETUP_ATTEMPTS_DISABLE);
+	}
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_NODE_SETUP_ATTEMPTS,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+E_CMBS_RC cmbs_dsr_han_GetMaxNumOfDevices (void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+    
+	return cmbs_int_EventSend(CMBS_EV_DSR_HAN_GET_MAX_NUM_OF_DEVICES, p_List->pu8_Buffer, p_List->u16_CurSize);
+	
+}
+
+E_CMBS_RC cmbs_dsr_han_GetNumOfRegDevices (void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+    
+	return cmbs_int_EventSend(CMBS_EV_DSR_HAN_GET_NUM_OF_REG_DEVICES, p_List->pu8_Buffer, p_List->u16_CurSize);
+	
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+E_CMBS_RC cmbs_dsr_han_device_Delete (void *pv_AppRefHandle, u16 u16_DeviceId )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd( p_List, u16_DeviceId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_FORCEFUL_DELETE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+	
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+E_CMBS_RC cmbs_dsr_han_DeviceBlackListDelete(void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd( p_List, u16_DeviceId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_BLACK_LIST_DELETE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+	
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+E_CMBS_RC cmbs_dsr_han_send_base_updated_notification (void *pv_AppRefHandle, u16 u16_DeviceId )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd( p_List, u16_DeviceId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_SEND_BASE_UPDATED_NOTIFICATION,p_List->pu8_Buffer, p_List->u16_CurSize);  
+	
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+E_CMBS_RC cmbs_dsr_han_get_fun_protocol_info (void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GET_FUN_PROTOCOL_INFO, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+E_CMBS_RC cmbs_dsr_han_device_GetConnectionStatus (void *pv_AppRefHandle, u16 u16_DeviceId )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd( p_List, u16_DeviceId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_GET_CONNECTION_STATUS ,p_List->pu8_Buffer, p_List->u16_CurSize);  
+	
+}
+
+E_CMBS_RC cmbs_dsr_han_fun_RegistationMsgRecv  (void *pv_AppRefHandle, PST_FUN_DEVICE_INFO pst_FunDeviceInfo)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HanFUNDeviceInfoAdd( p_List, pst_FunDeviceInfo );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_FUN_REG_MSG_RECV_RES, p_List->pu8_Buffer, p_List->u16_CurSize);  
+	
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_ReadDeviceRegistrationInformation (void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_MANGER_READ_DEVICE_SUB_INFO,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_ReadDeviceRegistrationInformationPhase2 (void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_MANGER_READ_DEVICE_SUB_INFO_PHASE_2,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Logger_SetLogLevel (void *pv_AppRefHandle, u8 u8_LogLevel)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANLogLevelAdd(p_List,u8_LogLevel);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_SET_LOG_LEVEL,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Logger_GetLogLevel (void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GET_LOG_LEVEL,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_ReadDeviceFullRegistrationInfo (void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_DeviceId, CMBS_IE_HAN_DEVICE);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_MANGER_READ_DEVICE_FULL_REGISTRATION_INFO,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_device_WriteDeviceFullRegistrationInfo (void *pv_AppRefHandle, u16 u16_DeviceId, ST_HAN_FULL_DEVICE_REGISTRATION_INFO *pst_DeviceRegistrationInfo)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_ShortValueAdd(p_List,u16_DeviceId, CMBS_IE_HAN_DEVICE);
+	cmbs_api_ie_HANDeviceFullRegistrationInfoAdd(p_List ,pst_DeviceRegistrationInfo);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_DEVICE_MANGER_WRITE_DEVICE_FULL_REGISTRATION_INFO, p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_logger_Control (void *pv_AppRefHandle, bool b_enable)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	if (b_enable)
+		{
+			return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GENERAL_LOGGER_ENABLED, p_List->pu8_Buffer, p_List->u16_CurSize);
+		}
+	else
+		{
+			return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GENERAL_LOGGER_DISABLED, p_List->pu8_Buffer, p_List->u16_CurSize);
+		}	  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_cp_logger_Control (void *pv_AppRefHandle, bool b_enable)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	if (b_enable)
+		{
+			return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CP_LOGGER_ENABLED, p_List->pu8_Buffer, p_List->u16_CurSize);
+		}
+	else
+		{
+			return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CP_LOGGER_DISABLED, p_List->pu8_Buffer, p_List->u16_CurSize);
+		}	  
+
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_MarkCcmKeyAsUsed(void *pv_AppRefHandle, u16 u16_DeviceNumber , u8 u8_CCMKeyUsed)
+{
+
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_MARK_CCM_KEY_AS_USED);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+	cmbs_api_ie_HANCcmKeyAsUsedAdd(p_List, u8_CCMKeyUsed);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_SetTxMicCorruptNum(void *pv_AppRefHandle,u16 u16_DeviceNumber)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_SET_TX_MIC_CORRUPTION_NUMBER);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_SetTxSeqNum(void *pv_AppRefHandle, u16 u16_DeviceNumber, u16 u16_TxSequenceNumber )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_SET_TX_SEQUENCE_NUMBER);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+	cmbs_api_ie_HANTxSequenceNumberAdd(p_List, u16_TxSequenceNumber);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_GetTxSeqNum(void *pv_AppRefHandle, u16 u16_DeviceNumber)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_GET_TX_SEQUENCE_NUMBER);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_GetRxSeqNum(void *pv_AppRefHandle, u16 u16_DeviceNumber)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_GET_RX_SEQUENCE_NUMBER);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_SetTxAckDropNum(void *pv_AppRefHandle, u16 u16_TxAckDropNumber)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_SET_TX_ACK_DROP_NUMBER);
+	cmbs_api_ie_HANTxAckDropNumberAdd(p_List, u16_TxAckDropNumber);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Certification_SetPvcState(void *pv_AppRefHandle, u16 u16_DeviceNumber, u8 u8_PVCState )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANCertificationOperationAdd(p_List, (u8) CMBS_HAN_ULE_DEVICE_CERTIFICATION_OPERATION_SET_PVC_STATE);
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+	cmbs_api_ie_HANPvcStateAdd(p_List, u8_PVCState);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_CERTIFICATION_OPERATION_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_SetRxGain(void *pv_AppRefHandle,  u8 u8_RxGainVal )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	cmbs_api_ie_HANRxGainAdd(p_List, u8_RxGainVal);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_SET_RX_GAIN, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_GetRxGain(void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_GET_RX_GAIN, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_SendPvcResetReq(void *pv_AppRefHandle, u16 u16_DeviceNumber)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_PVC_RESET_REQ, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_GetPvcResetReqState(void *pv_AppRefHandle, u16 u16_DeviceNumber)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	cmbs_api_ie_HANDeviceAdd(p_List, u16_DeviceNumber);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_PVC_RESET_REQ_STATE, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_NotifyOnVoiceCall (void *pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_NOTIFY_ON_VOICE_CALL_REQUEST,
+                               p_List->pu8_Buffer, 
+                               p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_TBR6SendPM(void *pv_AppRefHandle, u8  u8_Carrier , u32 u32_Period  )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANTBR6CarrierAdd(p_List, u8_Carrier);
+	cmbs_api_ie_HANTBR6PeriodAdd(p_List, u32_Period);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_TBR6_SEND_PM, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_TBR6SetGUCI(void *pv_AppRefHandle, u8 * pu8_IPUI )
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANULEDeviceIPUIAdd(p_List, (ST_IE_HAN_ULE_DEVICE_IPUI *)pu8_IPUI);
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_TBR6_SET_GUCI, p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_TBR6ResetStatistics (void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_TBR6_RESET_STATISTICS,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+E_CMBS_RC cmbs_dsr_han_UpdateDevicePMSeqNumbers (void *pv_AppRefHandle, u16 u16_DeviceId , u16 u16_RxSeqNum, u16 u16_TxSeqNum)
+{
+	PST_CFR_IE_LIST			p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd( p_List, u16_DeviceId );
+				
+	cmbs_api_ie_HANRxSequenceNumberAdd (p_List,u16_RxSeqNum);
+	cmbs_api_ie_HANTxSequenceNumberAdd (p_List,u16_TxSeqNum);	
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_UPDATE_DEVICE_PM_SEQ_NUMBERS,p_List->pu8_Buffer, p_List->u16_CurSize);  
+
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Start_Vbs(void * pv_AppRefHandle, u16 u16_GroupId)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANGroupIdAdd(p_List,u16_GroupId);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_START_VBS,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Stop_Vbs(void * pv_AppRefHandle, u16 u16_GroupId, PST_IE_MEDIA_CHANNEL pst_MediaChannel)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANGroupIdAdd(p_List,u16_GroupId);
+
+	if (pst_MediaChannel->u32_ChannelID != 0xFF)
+	{
+		cmbs_api_ie_MediaChannelAdd(p_List, pst_MediaChannel);
+	}
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_STOP_VBS,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Read_Broadcast_Channel_Type(void * pv_AppRefHandle, u8 u8_BroadcastChannelId)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANBroadcastChannelIdAdd(p_List,u8_BroadcastChannelId);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_READ_BROADCAST_CHANNEL_TYPE,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+E_CMBS_RC cmbs_dsr_han_Read_Device_VBS_Capabilties(void * pv_AppRefHandle, u16 u16_DeviceId)
+{
+	PST_CFR_IE_LIST		p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	UNUSED_PARAMETER(pv_AppRefHandle);
+
+	cmbs_api_ie_HANDeviceAdd(p_List,u16_DeviceId);
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_HAN_READ_DEVICE_VBS_CAPABILITIES,p_List->pu8_Buffer, p_List->u16_CurSize);  
+}
+
+
+/*---------[End Of File]---------------------------------------------------------------------------------------------------------------------------*/

dectmngr/src/cmbs/cmbs_han_ie.h

@@ -0,0 +1,218 @@
+/*!
+*  \file       cmbs_han_ie.h
+*  \brief      Information Elements List functions for HAN
+*  \author     andriig
+*
+*  @(#)  %filespec: cmbs_han_ie.h~ILD53#3 %
+*
+*******************************************************************************/
+
+#if   !defined( CMBS_HAN_IE_H )
+#define  CMBS_HAN_IE_H
+
+#include "cmbs_han.h"               /* CMBS HAN API definition */
+#include "cmbs_fun.h"
+
+E_CMBS_RC cmbs_api_ie_HanCfgAdd( void * pv_RefIEList, ST_IE_HAN_CONFIG* pst_Cfg);
+E_CMBS_RC cmbs_api_ie_HanCfgGet( void * pv_RefIEList, ST_IE_HAN_CONFIG* pst_Cfg);
+
+E_CMBS_RC		  cmbs_api_ie_HanUleBaseInfoAdd( void * pv_RefIEList, ST_IE_HAN_BASE_INFO* pst_HanBaseInfo);
+E_CMBS_RC		  cmbs_api_ie_HanUleBaseInfoGet( void * pv_RefIEList, ST_IE_HAN_BASE_INFO* pst_HanBaseInfo);
+
+E_CMBS_RC  cmbs_api_ie_HANDeviceSubInfoAdd( void * pv_RefIEList,  ST_HAN_EXTENDED_DEVICE_INFO * pst_HANExtendedDeviceEntry);
+E_CMBS_RC  cmbs_api_ie_HANDeviceSubInfoGet( void * pv_RefIEList,   ST_HAN_EXTENDED_DEVICE_INFO * pst_HANExtendedDeviceEntry);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceTableBriefAdd	( void * pv_RefIEList, ST_IE_HAN_BRIEF_DEVICE_ENTRIES* pst_HanDeviceEntries);
+E_CMBS_RC cmbs_api_ie_HANDeviceTableBriefGet (void * pv_RefIE, ST_IE_HAN_BRIEF_DEVICE_ENTRIES * pst_HANDeviceTable);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceTableExtendedAdd	( void * pv_RefIEList, ST_IE_HAN_EXTENDED_DEVICE_ENTRIES* pst_HANExtendedDeviceEntries);
+E_CMBS_RC cmbs_api_ie_HANDeviceTableExtendedGet (void * pv_RefIE, ST_IE_HAN_EXTENDED_DEVICE_ENTRIES* pst_HANExtendedDeviceEntries);
+	
+E_CMBS_RC cmbs_api_ie_HANRegStage1OKResParamsAdd	( void * pv_RefIEList, ST_HAN_REG_STAGE_1_STATUS* pst_RegStatus);
+E_CMBS_RC cmbs_api_ie_HANRegStage1OKResParamsGet (void * pv_RefIE, ST_HAN_REG_STAGE_1_STATUS* pst_RegStatus);
+
+E_CMBS_RC cmbs_api_ie_HANRegStage2OKResParamsAdd	( void * pv_RefIEList,ST_HAN_REG_STAGE_2_STATUS* pst_RegStatus);
+E_CMBS_RC cmbs_api_ie_HANRegStage2OKResParamsGet (void * pv_RefIE, ST_HAN_REG_STAGE_2_STATUS* pst_RegStatus);
+
+E_CMBS_RC cmbs_api_ie_HANBindTableAdd	( void * pv_RefIEList, ST_IE_HAN_BIND_ENTRIES*	 pst_HanBinds);
+E_CMBS_RC cmbs_api_ie_HANBindTableGet (void * pv_RefIE, ST_IE_HAN_BIND_TABLE * pst_HANBindTable);
+
+E_CMBS_RC cmbs_api_ie_HANGroupTableAdd	( void * pv_RefIEList, ST_IE_HAN_GROUP_ENTRIES*  pst_HanGroups);
+E_CMBS_RC cmbs_api_ie_HANGroupTableGet (void * pv_RefIE, ST_IE_HAN_GROUP_TABLE * pst_HANGroupTable);
+
+E_CMBS_RC cmbs_api_ie_HanMsgRegInfoAdd	( void * pv_RefIEList, ST_HAN_MSG_REG_INFO * pst_HANMsgRegInfo);
+E_CMBS_RC cmbs_api_ie_HanMsgRegInfoGet	( void * pv_RefIEList, ST_HAN_MSG_REG_INFO * pst_HANMsgRegInfo);
+
+E_CMBS_RC cmbs_api_ie_HANMsgAdd	( void * pv_RefIE, ST_IE_HAN_MSG * pst_HANMsg);
+E_CMBS_RC cmbs_api_ie_HANMsgGet (void * pv_RefIE, ST_IE_HAN_MSG * pst_HANMsg);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceAdd (void * pv_RefIE, u16 pu16_HANDevice);
+E_CMBS_RC cmbs_api_ie_HANDeviceGet (void * pv_RefIE, u16* pu16_HANDevice);
+
+E_CMBS_RC cmbs_api_ie_HANSendErrorReasonAdd (void * pv_RefIE, u16 u16_Reason);
+E_CMBS_RC cmbs_api_ie_HANSendErrorReasonGet (void * pv_RefIE, u16* pu16_Reason);
+
+E_CMBS_RC cmbs_api_ie_HANTxEndedReasonAdd (void * pv_RefIE, u16 u16_Reason);
+E_CMBS_RC cmbs_api_ie_HANTxEndedReasonGet (void * pv_RefIE, u16* pu16_Reason);
+
+E_CMBS_RC cmbs_api_ie_HANNumOfEntriesAdd( void * pv_RefIEList, u16 u16_NumOfEntries);
+E_CMBS_RC cmbs_api_ie_HANNumOfEntriesGet( void * pv_RefIEList, u16 * pu16_NumOfEntries);
+
+E_CMBS_RC cmbs_api_ie_HANIndex1stEntryAdd( void * pv_RefIEList, u16 u16_IndexOfFirstEntry);
+E_CMBS_RC cmbs_api_ie_HANIndex1stEntryGet( void * pv_RefIEList, u16 * pu16_IndexOfFirstEntry);
+
+E_CMBS_RC cmbs_api_ie_HANTableUpdateInfoAdd (void * pv_RefIE, ST_IE_HAN_TABLE_UPDATE_INFO * pst_HANTableUpdateInfo);
+E_CMBS_RC cmbs_api_ie_HANTableUpdateInfoGet (void * pv_RefIE, ST_IE_HAN_TABLE_UPDATE_INFO * pst_HANTableUpdateInfo);
+
+E_CMBS_RC cmbs_api_ie_HANGeneralStatusAdd( void * pv_RefIEList, ST_HAN_GENERAL_STATUS* pst_Status);
+E_CMBS_RC cmbs_api_ie_HANGeneralStatusGet( void * pv_RefIEList, ST_HAN_GENERAL_STATUS* pst_Status);
+
+E_CMBS_RC cmbs_api_ie_HANUnknownDeviceContactedParamsAdd( void * pv_RefIEList, ST_HAN_UNKNOWN_DEVICE_CONTACT_PARAMS* pst_Params);
+E_CMBS_RC cmbs_api_ie_HANUnknownDeviceContactedParamsGet( void * pv_RefIEList, ST_HAN_UNKNOWN_DEVICE_CONTACT_PARAMS* pst_Params);
+
+E_CMBS_RC cmbs_api_ie_HANConnectionStatusAdd (void * pv_RefIE, u16 pu16_ConnectionStatus);
+E_CMBS_RC cmbs_api_ie_HANConnectionStatusGet (void * pv_RefIE, u16* pu16_ConnectionStatus);
+
+E_CMBS_RC cmbs_api_ie_HANForcefulDeRegErrorReasonAdd (void * pv_RefIE, u16 u16_Reason);
+E_CMBS_RC cmbs_api_ie_HANForcefulDeRegErrorReasonGet (void * pv_RefIE, u16* pu16_Reason);
+
+E_CMBS_RC cmbs_api_ie_HANRegErrorReasonAdd (void * pv_RefIE, u16 u16_Reason);
+E_CMBS_RC cmbs_api_ie_HANRegErrorReasonGet (void * pv_RefIE, u16* pu16_Reason);
+
+E_CMBS_RC cmbs_api_ie_HANReqIDAdd (void * pv_RefIE, u16 u16_RequestID );
+E_CMBS_RC cmbs_api_ie_HANReqIDGet (void * pv_RefIE, u16* pu16_RequestID);
+
+E_CMBS_RC cmbs_api_ie_HANMsgCtlAdd (void * pv_RefIE, PST_IE_HAN_MSG_CTL pst_MessageControl);
+E_CMBS_RC cmbs_api_ie_HANMsgCtlGet (void * pv_RefIE, PST_IE_HAN_MSG_CTL pst_MessageControl);
+
+E_CMBS_RC  cmbs_api_ie_HanFUNDeviceInfoAdd( void * pv_RefIEList, ST_FUN_DEVICE_INFO* FunDevInfo);
+E_CMBS_RC  cmbs_api_ie_HanFUNDeviceInfoGet( void * pv_RefIEList, ST_FUN_DEVICE_INFO* FunDevInfo);
+
+E_CMBS_RC cmbs_api_ie_HANBindEntryAdd	( void * pv_RefIEList, PST_HAN_BIND_ENTRY pst_HANBindEntry);
+E_CMBS_RC cmbs_api_ie_HANBindEntryGet	( void * pv_RefIEList, PST_HAN_BIND_ENTRY pst_HANBindEntry);
+
+E_CMBS_RC cmbs_api_ie_HANTxReqResReasonAdd (void * pv_RefIE, u16  u16_TxReqResReason);
+E_CMBS_RC cmbs_api_ie_HANTxReqResReasonGet (void * pv_RefIE, u16* pu16_TxReqResReason);
+
+E_CMBS_RC cmbs_api_ie_HANLogLevelAdd (void * pv_RefIE, u8 u8_LogLevel);
+E_CMBS_RC cmbs_api_ie_HANLogLevelGet (void * pv_RefIE, u8 *pu8_LogLevel);
+
+E_CMBS_RC cmbs_api_ie_HANCertificationOperationAdd (void * pv_RefIE, u8 u8_CertificationOperationValue);
+E_CMBS_RC cmbs_api_ie_HANCertificationOperationGet (void * pv_RefIE, u8 *pu8_CertificationOperationValue);
+
+E_CMBS_RC cmbs_api_ie_HANCcmKeyAsUsedAdd(void * pv_RefIE, u8 u8_CcmKeyUsed);
+E_CMBS_RC cmbs_api_ie_HANCcmKeyAsUsedGet(void * pv_RefIE, u8 *pu8_CcmKeyUsed);
+
+E_CMBS_RC cmbs_api_ie_HANRxSequenceNumberAdd(void * pv_RefIE, u16 u16_RxSequenceNumber);
+E_CMBS_RC cmbs_api_ie_HANRxSequenceNumberGet (void * pv_RefIE, u16 *pu16_RxSequenceNumber);
+
+E_CMBS_RC cmbs_api_ie_HANTxSequenceNumberAdd(void * pv_RefIE, u16 u16_TxSequenceNumber);
+E_CMBS_RC cmbs_api_ie_HANTxSequenceNumberGet (void * pv_RefIE, u16 *pu16_TxSequenceNumber);
+
+E_CMBS_RC cmbs_api_ie_HANTxAckDropNumberAdd(void * pv_RefIE, u16 u16_TxAckDropNumber);
+E_CMBS_RC cmbs_api_ie_HANTxAckDropNumberGet(void * pv_RefIE, u16 *pu16_TxAckDropNumber);
+
+E_CMBS_RC cmbs_api_ie_HANPvcStateAdd(void * pv_RefIE, u8 u8_PVCState);
+E_CMBS_RC cmbs_api_ie_HANPvcStateGet (void * pv_RefIE, u8 *pu8_PVCState);
+
+E_CMBS_RC cmbs_api_ie_HANRxGainGet (void * pv_RefIE, u8 *pu8_RxGain);
+E_CMBS_RC cmbs_api_ie_HANRxGainAdd (void * pv_RefIE, u8 u8_RxGain);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceFullRegistrationInfoAdd( void * pv_RefIEList, ST_HAN_FULL_DEVICE_REGISTRATION_INFO* pst_HANCompleteRegistrationDeviceEntry);
+E_CMBS_RC cmbs_api_ie_HANDeviceFullRegistrationInfoGet( void * pv_RefIEList, ST_HAN_FULL_DEVICE_REGISTRATION_INFO* pst_HANCompleteRegistrationDeviceEntry);
+
+E_CMBS_RC cmbs_api_ie_HANReadDeviceFullRegInfoResReasonAdd (void * pv_RefIE, u8  u8_ReadDeviceFullRegInfoResReason);
+E_CMBS_RC cmbs_api_ie_HANReadDeviceFullRegInfoResReasonGet (void * pv_RefIE, u8  * pu8_ReadDeviceFullRegInfoResReason);
+
+E_CMBS_RC cmbs_api_ie_HANTBR6CarrierGet (void * pv_RefIE, u8 *pu8_TBR6Carrier);
+E_CMBS_RC cmbs_api_ie_HANTBR6CarrierAdd (void * pv_RefIE, u8 u8_TBR6Carrier);
+
+E_CMBS_RC cmbs_api_ie_HANTBR6PeriodGet (void * pv_RefIE, u32 *pu32_TBR6Period);
+E_CMBS_RC cmbs_api_ie_HANTBR6PeriodAdd (void * pv_RefIE, u32 u32_TBR6Period);
+
+E_CMBS_RC cmbs_api_ie_HANULEDeviceIPUIAdd	( void * pv_RefIEList, ST_IE_HAN_ULE_DEVICE_IPUI* pst_Ipui);
+E_CMBS_RC cmbs_api_ie_HANULEDeviceIPUIGet (void * pv_RefIE,ST_IE_HAN_ULE_DEVICE_IPUI* pst_Ipui);
+
+E_CMBS_RC cmbs_api_ie_HANULETBR6StatisticsAdd (void * pv_RefIE,ST_IE_HAN_ULE_TBR6_STATISTICS * p_cp_st_ULETBR6Stats);
+E_CMBS_RC cmbs_api_ie_HANULETBR6StatisticsGet (void * pv_RefIE,ST_IE_HAN_ULE_TBR6_STATISTICS * p_cp_st_ULETBR6Stats);
+
+E_CMBS_RC cmbs_api_ie_HANCarrierGet (void * pv_RefIE, u8 *pu8_Carrier);
+E_CMBS_RC cmbs_api_ie_HANCarrierAdd (void * pv_RefIE, u8 u8_Carrier);
+
+E_CMBS_RC cmbs_api_ie_HANSlotGet (void * pv_RefIE, u8 *pu8_Slot);
+E_CMBS_RC cmbs_api_ie_HANSlotAdd (void * pv_RefIE, u8 u8_Slot);
+
+E_CMBS_RC cmbs_api_ie_HanReqFailureReasonGet (void * pv_RefIE, u8 *u8_Reason);
+E_CMBS_RC cmbs_api_ie_HanReqFailureReasonAdd (void * pv_RefIE, u8 u8_Reason);
+
+E_CMBS_RC cmbs_api_ie_HanULEPagingIntervalGet (void * pv_RefIE, u32 *u32_ULEPagingInterval);
+E_CMBS_RC cmbs_api_ie_HanULEPagingIntervalAdd (void * pv_RefIE, u32 u32_ULEPagingInterval);
+
+E_CMBS_RC cmbs_api_ie_HanULEPagingIntervalModificationFailureReasonGet (void * pv_RefIE, u8 *u8_Reason);
+E_CMBS_RC cmbs_api_ie_HanULEPagingIntervalModificationFailureReasonAdd (void * pv_RefIE, u8 u8_Reason);
+
+E_CMBS_RC cmbs_api_ie_HanNodeSetupAttemptsEnableGet (void * pv_RefIE, u8 *u8_Enable);
+E_CMBS_RC cmbs_api_ie_HanNodeSetupAttemptsEnableAdd (void * pv_RefIE, u8 u8_Enable);
+
+E_CMBS_RC cmbs_api_ie_HanDeviceLinkReleaseReasonGet (void * pv_RefIE, u8 *pu8_ReleaseReason);
+E_CMBS_RC cmbs_api_ie_HanDeviceLinkReleaseReasonAdd (void * pv_RefIE, u8 u8_ReleaseReason);
+
+E_CMBS_RC cmbs_api_ie_HanMaxNumOfDevicesGet (void * pv_RefIE, u16 *pu16_MaxNumOfDevices);
+E_CMBS_RC cmbs_api_ie_HanMaxNumOfDevicesAdd (void * pv_RefIE, u16 u16_MaxNumOfDevices);
+
+E_CMBS_RC cmbs_api_ie_HanNumOfRegDevicesGet(void * pv_RefIE, u16 * pu16_NumOfRegDevices);
+E_CMBS_RC cmbs_api_ie_HanNumOfRegDevicesAdd(void * pv_RefIE, u16  u16_NumOfRegDevices);
+
+E_CMBS_RC cmbs_api_ie_HANGroupIdAdd (void * pv_RefIE, u16 u16_GroupId);
+E_CMBS_RC cmbs_api_ie_HANGroupIdGet (void * pv_RefIE, u16* pu16_GroupId);
+
+E_CMBS_RC cmbs_api_ie_HANGroupCommandFailureReasonAdd (void * pv_RefIE, u8 u8_GroupCommandFailReason);
+E_CMBS_RC cmbs_api_ie_HANGroupCommandFailureReasonGet (void * pv_RefIE, u8* pu8_GroupCommandFailReason);
+
+E_CMBS_RC cmbs_api_ie_HANUnitIdAdd (void * pv_RefIE, u8 pu8_UnitId);
+E_CMBS_RC cmbs_api_ie_HANUnitIdGet (void * pv_RefIE, u8* pu8_UnitId);
+
+E_CMBS_RC cmbs_api_ie_HANGroupListAdd ( void * pv_RefIEList, ST_IE_HAN_GROUP_LIST_ENTRIES*  pst_HanGroupList);
+E_CMBS_RC cmbs_api_ie_HANGroupListGet ( void * pv_RefIEList, ST_IE_HAN_GROUP_LIST_ENTRIES*  pst_HanGroupList);
+
+E_CMBS_RC cmbs_api_ie_HANMsgRSSIAdd ( void * pv_RefIE, u8 u8_RSSI);
+E_CMBS_RC cmbs_api_ie_HANMsgRSSIGet ( void * pv_RefIE, u8* u8_RSSI);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceBlackListDeleteErrorReasonAdd (void * pv_RefIE, u16 u16_Reason);
+E_CMBS_RC cmbs_api_ie_HANDeviceBlackListDeleteErrorReasonGet (void * pv_RefIE, u16* pu16_Reason);
+
+E_CMBS_RC cmbs_api_ie_HANUleCapabilitiesAdd (void * pv_RefIE, u16 u16_UleCapabilities);
+E_CMBS_RC cmbs_api_ie_HANUleCapabilitiesGet (void * pv_RefIE, u16* pu16_UleCapabilities);
+
+E_CMBS_RC cmbs_api_ie_HANBroadcastChannelIdGet (void * pv_RefIE, u8 *pu8_BroadcastChannelId);
+E_CMBS_RC cmbs_api_ie_HANBroadcastChannelIdAdd (void * pv_RefIE, u8 u8_BroadcastChannelId);
+
+E_CMBS_RC cmbs_api_ie_HANBroadcastChannelTableAdd	( void * pv_RefIEList, ST_IE_HAN_BROADCAST_CHANNEL_ENTRIES*  pst_BroadcastChannelTable);
+E_CMBS_RC cmbs_api_ie_HANBroadcastChannelTableGet	( void * pv_RefIEList, ST_IE_HAN_BROADCAST_CHANNEL_ENTRIES*  pst_BroadcastChannelTable);
+
+E_CMBS_RC cmbs_api_ie_HANPvcResetReqFailureReasonGet (void * pv_RefIE, u8 *pu8_PvcResetReqFailureReason);
+E_CMBS_RC cmbs_api_ie_HANPvcResetReqFailureReasonAdd (void * pv_RefIE, u8 u8_PvcResetReqFailureReason);
+
+E_CMBS_RC cmbs_api_ie_HANPvcResetReqStateFailureReasonGet (void * pv_RefIE, u8 *pu8_PvcResetReqStateFailureReason);
+E_CMBS_RC cmbs_api_ie_HANPvcResetReqStateFailureReasonAdd (void * pv_RefIE, u8 u8_PvcResetReqStateFailureReason);
+
+E_CMBS_RC cmbs_api_ie_HANPvcResetReqStateGet (void * pv_RefIE, u8 *pu8_PvcResetReqState);
+E_CMBS_RC cmbs_api_ie_HANPvcResetReqStateAdd (void * pv_RefIE, u8 u8_PvcResetReqState);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceTableExtendedPhase2Get( void * pv_RefIEList,ST_IE_HAN_EXTENDED_DEVICE_PHASE_2_ENTRIES* pst_HANExtendedDeviceEntries);
+E_CMBS_RC cmbs_api_ie_HANDeviceTableExtendedPhase2Add( void * pv_RefIEList, ST_IE_HAN_EXTENDED_DEVICE_PHASE_2_ENTRIES* pst_HANExtendedDeviceEntries);
+
+E_CMBS_RC cmbs_api_ie_HANDeviceSubInfoPhase2Add( void * pv_RefIEList,  ST_HAN_EXTENDED_DEVICE_INFO_PHASE_2 * pst_HANExtendedDeviceEntry);
+E_CMBS_RC cmbs_api_ie_HANDeviceSubInfoPhase2Get( void * pv_RefIEList,  ST_HAN_EXTENDED_DEVICE_INFO_PHASE_2 * pst_HANExtendedDeviceEntry);
+
+
+E_CMBS_RC cmbs_api_ie_HANDeviceVBSCapAdd (void * pv_RefIE, u8 u8_VbsCap);
+E_CMBS_RC cmbs_api_ie_HANDeviceVBSCapGet (void * pv_RefIE, u8* pu8_VbsCap);
+
+E_CMBS_RC cmbs_api_ie_HANBroadcastChannelTypeGet (void * pv_RefIE, u8 *pu8_BroadcastChannelType);
+E_CMBS_RC cmbs_api_ie_HANBroadcastChannelTypeAdd (void * pv_RefIE, u8 u8_BroadcastChannelType);
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#endif	// CMBS_HAN_IE_H

dectmngr/src/cmbs/cmbs_ie.h

@@ -0,0 +1,362 @@
+/*!
+*  \file       cmbs_ie.h
+*  \brief      Information Elements List functions
+*  \author     andriig
+*
+*  @(#)  %filespec: cmbs_ie.h~7 %
+*
+*******************************************************************************/
+
+#if   !defined( CMBS_IE_H )
+#define  CMBS_IE_H
+#include "cmbs_api.h"               /* CMBS API definition */
+
+/* Allocate IE list and verify it */
+#define ALLOCATE_IE_LIST(p_List)						\
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();	\
+	if(!p_List)											\
+	return CMBS_RC_ERROR_OUT_OF_MEM;					
+
+/* Get IE type and check it */
+#define CHECK_IE_TYPE(pu8_Buffer, IEType)							\
+	{																\
+		u16		u16_Type = 0;										\
+		cfr_ie_dser_u16( pu8_Buffer + CFR_IE_TYPE_POS, &u16_Type );	\
+		if ( IEType != u16_Type )									\
+			return CMBS_RC_ERROR_PARAMETER;							\
+	}
+
+void * cmbs_api_ie_GetList( void );
+
+E_CMBS_RC cmbs_api_ie_DeregisterThread (u32 u32_ThreadId);
+
+E_CMBS_RC cmbs_api_ie_GetFirst( void * pv_RefIEList, void ** ppv_RefIE, u16 * pu16_IEType );
+E_CMBS_RC cmbs_api_ie_GetNext( void * pv_RefIEList, void ** ppv_RefIE, u16 * pu16_IEType );
+E_CMBS_RC cmbs_api_ie_GetIE( void * pv_RefIEList, void ** ppv_RefIE, u16 pu16_IEType );
+
+E_CMBS_RC cmbs_api_ie_ByteValueAdd( void * pv_RefIEList, u8 u8_Value, E_CMBS_IE_TYPE e_IETYPE );
+E_CMBS_RC cmbs_api_ie_ByteValueGet( void * pv_RefIE, u8 * pu8_Value, E_CMBS_IE_TYPE e_IETYPE );
+E_CMBS_RC cmbs_api_ie_ShortValueAdd( void * pv_RefIEList, u16 u16_Value, E_CMBS_IE_TYPE e_IETYPE );
+E_CMBS_RC cmbs_api_ie_ShortValueGet( void * pv_RefIE, u16 * pu16_Value, E_CMBS_IE_TYPE e_IETYPE );
+E_CMBS_RC cmbs_api_ie_u32ValueAdd( void * pv_RefIEList, u32 u32_Value, E_CMBS_IE_TYPE e_IEType );
+E_CMBS_RC cmbs_api_ie_u32ValueGet( void * pv_RefIE, u32 * pu32_Value, E_CMBS_IE_TYPE e_IEType );
+
+E_CMBS_RC cmbs_api_ie_IntValueAdd( void * pv_RefIEList, u32 u32_Value );
+E_CMBS_RC cmbs_api_ie_IntValueGet( void * pv_RefIE, u32 * pu32_Value );
+E_CMBS_RC cmbs_api_ie_LineIdAdd( void * pv_RefIEList, u8 u8_LineId );
+E_CMBS_RC cmbs_api_ie_LineIdGet( void * pv_RefIE, u8 * pu8_LineId );
+E_CMBS_RC cmbs_api_ie_MelodyAdd( void * pv_RefIEList, u8 u8_Melody );
+E_CMBS_RC cmbs_api_ie_MelodyGet( void * pv_RefIE, u8 * pu8_Melody );
+E_CMBS_RC cmbs_api_ie_SplashTimerAdd(void *pv_RefIEList, u8 u8_SplashTimer);
+E_CMBS_RC cmbs_api_ie_SplashTimerGet(void *pv_RefIE, u8 *pu8_SplashTimer);
+E_CMBS_RC cmbs_api_ie_ReconnectGet(void *pv_RefIE, u8 *pu8_Reconnect);
+E_CMBS_RC cmbs_api_ie_CallInstanceAdd( void * pv_RefIEList, u32 u32_CallInstance );
+E_CMBS_RC cmbs_api_ie_CallInstanceGet( void * pv_RefIE, u32 * pu32_CallInstance );
+E_CMBS_RC cmbs_api_ie_RequestIdAdd( void * pv_RefIE, u16 pu16_RequestId );
+E_CMBS_RC cmbs_api_ie_RequestIdGet( void * pv_RefIE, u16 * pu16_RequestId );
+E_CMBS_RC cmbs_api_ie_HandsetsAdd( void * pv_RefIE, u16  u16_Handsets );
+E_CMBS_RC cmbs_api_ie_HandsetsGet( void * pv_RefIE, u16 * pu16_Handsets );
+E_CMBS_RC cmbs_api_ie_HsNumberAdd( void * pv_RefIEList, u8 u8_HsNumber );
+E_CMBS_RC cmbs_api_ie_MaxRepSubAdd(void *pv_RefIEList, u8 u8_HsNumber);
+E_CMBS_RC cmbs_api_ie_MaxRepHsSubAdd(void *pv_RefIEList, u8 u8_HsNumber);
+E_CMBS_RC cmbs_api_ie_RepNumberGet(void *pv_RefIE, u8 *pu8_HsNumber);
+E_CMBS_RC cmbs_api_ie_RepHsNumberGet(void *pv_RefIE, u8 *pu8_HsNumber);
+
+
+E_CMBS_RC cmbs_api_ie_HsNumberGet( void * pv_RefIE, u8 * pu8_HsNumber );
+E_CMBS_RC cmbs_api_ie_GpioAdd( void * pv_RefIEList, u16 u16_Gpio );
+E_CMBS_RC cmbs_api_ie_GpioGet( void * pv_RefIE, u16 * pu16_Gpio );
+
+E_CMBS_RC cmbs_api_ie_CallTransferReqAdd( void * pv_RefIEList, PST_IE_CALLTRANSFERREQ pst_CallTrf );
+E_CMBS_RC cmbs_api_ie_CallTransferReqGet( void * pv_RefIE, PST_IE_CALLTRANSFERREQ pst_CallTrf );
+E_CMBS_RC cmbs_api_ie_InternalCallTransferReqAdd( void * pv_RefIEList, PST_IE_INTERNAL_TRANSFER pst_InternalTransfer );
+E_CMBS_RC cmbs_api_ie_InternalCallTransferReqGet( void * pv_RefIE, PST_IE_INTERNAL_TRANSFER pst_InternalTransfer );
+E_CMBS_RC cmbs_api_ie_CallerPartyAdd( void * pv_RefIEList, ST_IE_CALLERPARTY * pst_CallerParty );
+E_CMBS_RC cmbs_api_ie_CallerPartyGet( void * pv_RefIE, ST_IE_CALLERPARTY * pst_CallerParty );
+E_CMBS_RC cmbs_api_ie_CalledPartyAdd( void * pv_RefIEList, ST_IE_CALLEDPARTY * pst_CalledParty );
+E_CMBS_RC cmbs_api_ie_CalledPartyGet( void * pv_RefIE, ST_IE_CALLEDPARTY * pst_CalledParty );
+E_CMBS_RC cmbs_api_ie_CallerNameAdd( void * pv_RefIEList, ST_IE_CALLERNAME * pst_CallerName );
+E_CMBS_RC cmbs_api_ie_CallerNameGet( void * pv_RefIE, ST_IE_CALLERNAME * pst_CallerName );
+E_CMBS_RC cmbs_api_ie_CallProgressAdd( void * pv_RefIEList, ST_IE_CALLPROGRESS * pst_CallProgress );
+E_CMBS_RC cmbs_api_ie_CallProgressGet( void * pv_RefIE, ST_IE_CALLPROGRESS * pst_CallProgress );
+E_CMBS_RC cmbs_api_ie_CallInfoAdd( void * pv_RefIEList, ST_IE_CALLINFO * pst_CallInfo );
+E_CMBS_RC cmbs_api_ie_CallInfoGet( void * pv_RefIE, ST_IE_CALLINFO * pst_CallInfo );
+E_CMBS_RC cmbs_api_ie_DisplayStringAdd( void * pv_RefIEList, ST_IE_DISPLAY_STRING * pst_DisplayString );
+E_CMBS_RC cmbs_api_ie_CallReleaseReasonAdd( void * pv_RefIEList, ST_IE_RELEASE_REASON * pst_RelReason );
+E_CMBS_RC cmbs_api_ie_CallReleaseReasonGet( void * pv_RefIE, ST_IE_RELEASE_REASON * pst_RelReason );
+E_CMBS_RC cmbs_api_ie_CallStateGet( void * pv_RefIE, ST_IE_CALL_STATE * pst_CallState );
+E_CMBS_RC cmbs_api_ie_UpdatedDeviceStateGet(void *pv_RefIE, ST_IE_UPDATED_DEVICE_STATE *st_DeviceState);
+E_CMBS_RC cmbs_api_ie_DeviceListStatusGet(void *pv_RefIE, ST_IE_DEVICE_LIST_STATUS *st_DevListStatus);
+E_CMBS_RC cmbs_api_ie_MediaChannelAdd( void * pv_RefIEList, ST_IE_MEDIA_CHANNEL * pst_MediaChannel );
+E_CMBS_RC cmbs_api_ie_MediaChannelGet( void * pv_RefIE, ST_IE_MEDIA_CHANNEL * pst_MediaChannel );
+E_CMBS_RC cmbs_api_ie_AudioShmemAdd( void * pv_RefIEList, ST_IE_AUDIO_SHMEM * pst_ShmemParams );
+E_CMBS_RC cmbs_api_ie_AudioShmemGet( void * pv_RefIE, ST_IE_AUDIO_SHMEM * pst_ShmemParams );
+E_CMBS_RC cmbs_api_ie_MediaICAdd( void * pv_RefIEList, ST_IE_MEDIA_INTERNAL_CONNECT * pst_MediaIC );
+E_CMBS_RC cmbs_api_ie_MediaICGet( void * pv_RefIE, ST_IE_MEDIA_INTERNAL_CONNECT * pst_MediaIC );
+E_CMBS_RC cmbs_api_ie_MediaDescAdd( void * pv_RefIEList, ST_IE_MEDIA_DESCRIPTOR * pst_MediaDesc );
+E_CMBS_RC cmbs_api_ie_MediaDescGet( void * pv_RefIE, ST_IE_MEDIA_DESCRIPTOR * pst_MediaDesc );
+E_CMBS_RC cmbs_api_ie_ToneAdd( void * pv_RefIEList, ST_IE_TONE * pst_Tone );
+E_CMBS_RC cmbs_api_ie_ToneVolumeAdd(void *pv_RefIEList, u16 u16_TOGVOlume);
+E_CMBS_RC cmbs_api_ie_ToneVolumeGet(void *pv_RefIE, u16 *pu16_TOGVOlume);
+E_CMBS_RC cmbs_api_ie_TimeAdd( void * pv_RefIEList, ST_IE_TIMEOFDAY * pst_TimeOfDay );
+E_CMBS_RC cmbs_api_ie_TimeGet( void * pv_RefIE, ST_IE_TIMEOFDAY * pst_TimeOfDay );
+E_CMBS_RC cmbs_api_ie_HandsetInfoGet( void * pv_RefIE, ST_IE_HANDSETINFO * pst_HandsetInfo );
+E_CMBS_RC cmbs_api_ie_ParameterGet( void * pv_RefIE, ST_IE_PARAMETER * pst_Parameter );
+E_CMBS_RC cmbs_api_ie_SubscribedHSListAdd( void * pv_RefIE, ST_IE_SUBSCRIBED_HS_LIST * pst_SubscribedHsList );
+E_CMBS_RC cmbs_api_ie_SubscribedHSListGet( void * pv_RefIE, ST_IE_SUBSCRIBED_HS_LIST * pst_SubscribedHsList );
+E_CMBS_RC cmbs_api_ie_LAPropCmdAdd( void * pv_RefIE, ST_LA_PROP_CMD * pst_Cmd );
+E_CMBS_RC cmbs_api_ie_LAPropCmdGet( void * pv_RefIE, ST_LA_PROP_CMD * pst_Cmd );
+E_CMBS_RC cmbs_api_ie_LineSettingsListAdd( void * pv_RefIE, ST_IE_LINE_SETTINGS_LIST * pst_LineSettingsList );
+E_CMBS_RC cmbs_api_ie_LineSettingsListGet( void * pv_RefIE, ST_IE_LINE_SETTINGS_LIST * pst_LineSettingsList );
+E_CMBS_RC cmbs_api_ie_ParameterAreaGet( void * pv_RefIE, ST_IE_PARAMETER_AREA * pst_ParameterArea );
+E_CMBS_RC cmbs_api_ie_FwVersionGet( void * pv_RefIE, ST_IE_FW_VERSION * pst_FwVersion );
+E_CMBS_RC cmbs_api_ie_HwVersionGet( void * pv_RefIE, ST_IE_HW_VERSION * pst_HwVersion );
+E_CMBS_RC cmbs_api_ie_EEPROMVersionGet( void * pv_RefIE, ST_IE_EEPROM_VERSION * pst_EEPROMVersion );
+E_CMBS_RC cmbs_api_ie_SysLogGet( void * pv_RefIE, ST_IE_SYS_LOG * pst_SysLog );
+E_CMBS_RC cmbs_api_ie_SysStatusGet( void * pv_RefIE, ST_IE_SYS_STATUS * pst_SysStatus );
+E_CMBS_RC cmbs_api_ie_ResponseAdd( void * pv_RefIE, ST_IE_RESPONSE * pst_Response );
+E_CMBS_RC cmbs_api_ie_ResponseGet( void * pv_RefIE, ST_IE_RESPONSE * pst_Response );
+E_CMBS_RC cmbs_api_ie_DateTimeAdd( void * pv_RefIEList, ST_IE_DATETIME * pst_DateTime );
+E_CMBS_RC cmbs_api_ie_DateTimeGet( void * pv_RefIE, ST_IE_DATETIME * pst_DateTime );
+E_CMBS_RC cmbs_api_ie_DataGet( void * pv_RefIE, ST_IE_DATA * pst_Data );
+E_CMBS_RC cmbs_api_ie_DataSessionIdAdd( void * pv_RefIE, u16 pu16_DataSessionId );
+E_CMBS_RC cmbs_api_ie_DataSessionIdGet( void * pv_RefIE, u16 * pu16_DataSessionId );
+E_CMBS_RC cmbs_api_ie_DataSessionTypeGet( void * pv_RefIE, ST_IE_DATA_SESSION_TYPE * pst_DataSessionType );
+E_CMBS_RC cmbs_api_ie_LASessionIdAdd( void * pv_RefIE, u16 pu16_LASessionId );
+E_CMBS_RC cmbs_api_ie_LASessionIdGet( void * pv_RefIE, u16 * pu16_LASessionId );
+E_CMBS_RC cmbs_api_ie_LAListIdGet( void * pv_RefIE, u16 * pu16_LAListId );
+E_CMBS_RC cmbs_api_ie_LAListIdAdd( void * pv_RefIE, u16 u16_LAListId );
+E_CMBS_RC cmbs_api_ie_LAFieldsGet( void * pv_RefIE, ST_IE_LA_FIELDS * pst_LAFields );
+E_CMBS_RC cmbs_api_ie_LASearchCriteriaGet( void * pv_RefIE, ST_IE_LA_SEARCH_CRITERIA * pst_LASearchCriteria );
+E_CMBS_RC cmbs_api_ie_LAEntryIdGet( void * pv_RefIE, u16 * pu16_LAEntryId );
+E_CMBS_RC cmbs_api_ie_LAEntryIndexGet( void * pv_RefIE, u16 * pu16_LAEntryIndex );
+E_CMBS_RC cmbs_api_ie_LAEntryCountGet( void * pv_RefIE, u16 * pu16_LAEntryCount );
+E_CMBS_RC cmbs_api_ie_LAIsLastGet( void * pv_RefIE, u8 * pu8_LAIsLast );
+E_CMBS_RC cmbs_api_ie_ATESettingsGet( void * pv_RefIE, ST_IE_ATE_SETTINGS * pst_AteSettings );
+E_CMBS_RC cmbs_api_ie_ATESettingsAdd( void * pv_RefIEList, ST_IE_ATE_SETTINGS * pst_AteSettings );
+E_CMBS_RC cmbs_api_ie_ReadDirectionAdd( void * pv_RefIEList, ST_IE_READ_DIRECTION * pst_ReadDirection );
+E_CMBS_RC cmbs_api_ie_ReadDirectionGet( void * pv_RefIE, ST_IE_READ_DIRECTION * pst_ReadDirection );
+E_CMBS_RC cmbs_api_ie_MarkRequestAdd( void * pv_RefIEList, ST_IE_MARK_REQUEST * pst_MarkRequest );
+E_CMBS_RC cmbs_api_ie_MarkRequestGet( void * pv_RefIE, ST_IE_MARK_REQUEST * pst_MarkRequest );
+E_CMBS_RC cmbs_api_ie_VersionAvailAdd( void * pv_RefIEList, ST_SUOTA_UPGRADE_DETAILS* st_HSVerAvail );
+E_CMBS_RC cmbs_api_ie_VersionAvailGet (void * pv_RefIEList, ST_SUOTA_UPGRADE_DETAILS* pst_HSVerAvail );
+E_CMBS_RC cmbs_api_ie_VersionBufferAdd( void * pv_RefIEList, ST_VERSION_BUFFER* pst_SwVersion);
+E_CMBS_RC cmbs_api_ie_VersionBufferGet( void * pv_RefIEList, ST_VERSION_BUFFER* pst_SwVersion);
+E_CMBS_RC cmbs_api_ie_VersionIndGet( void * pv_RefIEList, ST_SUOTA_HS_VERSION_IND* pst_HSVerInd);
+E_CMBS_RC cmbs_api_ie_VersionIndAdd( void * pv_RefIEList, ST_SUOTA_HS_VERSION_IND* st_HSVerInd);
+E_CMBS_RC cmbs_api_ie_UrlAdd( void * pv_RefIEList, ST_URL_BUFFER* pst_Url);
+E_CMBS_RC cmbs_api_ie_UrlGet( void * pv_RefIEList, ST_URL_BUFFER* pst_Url);
+E_CMBS_RC cmbs_api_ie_NBOTACodecAdd( void *pv_RefIEList, PST_IE_NB_CODEC_OTA pst_Codec );
+E_CMBS_RC cmbs_api_ie_NBOTACodecGet( void *pv_RefIE, PST_IE_NB_CODEC_OTA pst_Codec );
+E_CMBS_RC cmbs_api_ie_TargetListChangeNotifAdd( void *pv_RefIEList, PST_IE_TARGET_LIST_CHANGE_NOTIF pst_Notif );
+E_CMBS_RC cmbs_api_ie_TargetListChangeNotifGet( void * pv_RefIE, PST_IE_TARGET_LIST_CHANGE_NOTIF pst_Notif );
+E_CMBS_RC cmbs_api_ie_DectSettingsListAdd( void * pv_RefIEList, ST_IE_DECT_SETTINGS_LIST * pst_DectSettings );
+E_CMBS_RC cmbs_api_ie_DectSettingsListGet( void * pv_RefIE, ST_IE_DECT_SETTINGS_LIST * pst_DectSettings );
+E_CMBS_RC cmbs_api_ie_RTPSessionInformationAdd( void * pv_RefIEList, const ST_IE_RTP_SESSION_INFORMATION * pst_RTPSessionInformation );
+E_CMBS_RC cmbs_api_ie_RTPSessionInformationGet( void * pv_RefIE, ST_IE_RTP_SESSION_INFORMATION * pst_RTPSessionInformation );
+E_CMBS_RC cmbs_api_ie_RTCPIntervalAdd( void * pv_RefIEList, u32 u32_RTCPInterval );
+E_CMBS_RC cmbs_api_ie_RTCPIntervalGet( void * pv_RefIE, u32 * pu32_RTCPInterval );
+E_CMBS_RC cmbs_api_ie_RTPDTMFEventAdd( void * pv_RefIEList, const ST_IE_RTP_DTMF_EVENT * pst_RTPDTMFEvent );
+E_CMBS_RC cmbs_api_ie_RTPDTMFEventGet( void * pv_RefIE, ST_IE_RTP_DTMF_EVENT * pst_RTPDTMFEvent );
+E_CMBS_RC cmbs_api_ie_RTPDTMFEventInfoAdd( void * pv_RefIEList, const ST_IE_RTP_DTMF_EVENT_INFO * pst_RTPDTMFEventInfo );
+E_CMBS_RC cmbs_api_ie_RTPDTMFEventInfoGet( void * pv_RefIE, ST_IE_RTP_DTMF_EVENT_INFO * pst_RTPDTMFEventInfo );
+E_CMBS_RC cmbs_api_ie_RTPFaxToneTypeAdd( void * pv_RefIEList, E_CMBS_FAX_TONE_TYPE e_FaxToneType );
+E_CMBS_RC cmbs_api_ie_RTPFaxToneTypeGet( void * pv_RefIE, E_CMBS_FAX_TONE_TYPE * pe_FaxToneType );
+E_CMBS_RC cmbs_api_ie_BaseNameAdd( void * pv_RefIE, ST_IE_BASE_NAME* pst_BaseName );
+E_CMBS_RC cmbs_api_ie_BaseNameGet( void * pv_RefIE, ST_IE_BASE_NAME* pst_BaseName );
+E_CMBS_RC cmbs_api_ie_RegCloseReasonGet(void * pv_RefIE, ST_IE_REG_CLOSE_REASON*	st_Reg_Close_Reason);
+E_CMBS_RC cmbs_api_ie_RegEnableTypeAdd(void *pv_RefIE, E_CMBS_HS_REGISTER_ENABLE e_RegEnable);
+E_CMBS_RC cmbs_api_ie_RegEnableTypeGet(void *pv_RefIE, u8 *u8_RegEnable);
+E_CMBS_RC cmbs_api_ie_DCRejectReasonGet(void * pv_RefIE, ST_IE_DC_REJECT_REASON*	st_DC_Reject_Reason);
+E_CMBS_RC cmbs_api_ie_DCRejectReasonAdd(void * pv_RefIE, ST_IE_DC_REJECT_REASON*	st_DC_Reject_Reason);
+E_CMBS_RC cmbs_api_ie_ParameterAdd( void * pv_RefIEList, ST_IE_PARAMETER * pst_Param );
+E_CMBS_RC cmbs_api_ie_ParameterAreaAdd( void * pv_RefIEList, ST_IE_PARAMETER_AREA * pst_ParamArea );
+E_CMBS_RC cmbs_api_ie_HandsetInfoAdd( void * pv_RefIEList, ST_IE_HANDSETINFO * pst_HandsetInfo );
+E_CMBS_RC cmbs_api_ie_DisplayStringGet( void * pv_RefIE, ST_IE_DISPLAY_STRING * pst_DisplayString );
+E_CMBS_RC cmbs_api_ie_ToneGet( void * pv_RefIE, ST_IE_TONE * pst_Tone );
+E_CMBS_RC cmbs_api_ie_FwVersionAdd( void * pv_RefIEList, ST_IE_FW_VERSION * pst_FwVersion );
+E_CMBS_RC cmbs_api_ie_EEPROMVersionAdd( void * pv_RefIEList, ST_IE_EEPROM_VERSION * pst_EEPROMVersion );
+E_CMBS_RC cmbs_api_ie_HwVersionAdd( void * pv_RefIEList, ST_IE_HW_VERSION * pst_HwVersion );
+E_CMBS_RC cmbs_api_ie_SysLogAdd( void * pv_RefIEList, ST_IE_SYS_LOG * pst_SysLog );
+E_CMBS_RC cmbs_api_ie_SysStatusAdd( void * pv_RefIEList, ST_IE_SYS_STATUS * pst_SysStatus );
+E_CMBS_RC cmbs_api_ie_GenEventAdd( void * pv_RefIEList, ST_IE_GEN_EVENT * pst_GenEvent );
+E_CMBS_RC cmbs_api_ie_GenEventGet( void * pv_RefIE, ST_IE_GEN_EVENT * pst_GenEvent );
+E_CMBS_RC cmbs_api_ie_PropEventAdd( void * pv_RefIEList, ST_IE_PROP_EVENT * pst_PropEvent );
+E_CMBS_RC cmbs_api_ie_PropEventGet( void * pv_RefIE, ST_IE_PROP_EVENT * pst_PropEvent );
+E_CMBS_RC cmbs_api_ie_PropEventNotifyAdd(void *pv_RefIEList, ST_IE_PROP_EVENT_NOTIFY *pst_PropEvent);
+E_CMBS_RC cmbs_api_ie_PropEventNotifyGet(void *pv_RefIE, ST_IE_PROP_EVENT_NOTIFY *pst_PropEvent);
+E_CMBS_RC cmbs_api_ie_GenEventDetailsAdd(void *pv_RefIEList, ST_IE_GEN_EVENT_DETAILS *pst_GenEventDetails);
+E_CMBS_RC cmbs_api_ie_GenEventDetailsGet(void *pv_RefIE, ST_IE_GEN_EVENT_DETAILS *pst_GenEventDetails);
+
+
+E_CMBS_RC cmbs_api_ie_DataSessionTypeAdd( void * pv_RefIEList, ST_IE_DATA_SESSION_TYPE * pst_DataSessionType );
+E_CMBS_RC cmbs_api_ie_DataAdd( void * pv_RefIEList, ST_IE_DATA * pst_Data );
+E_CMBS_RC cmbs_api_ie_CallStateAdd( void * pv_RefIEList, ST_IE_CALL_STATE * pst_CallState );
+E_CMBS_RC cmbs_api_ie_LAFieldsAdd( void * pv_RefIEList, ST_IE_LA_FIELDS * pst_LAFields, E_CMBS_IE_TYPE e_IEType );
+E_CMBS_RC cmbs_api_ie_LASelectionTypeAdd(void *pv_RefIE, u16 u16_SelectionType);
+E_CMBS_RC cmbs_api_ie_LASelectionTypeGet(void *pv_RefIE, u16 *u16_SelectionType);
+E_CMBS_RC cmbs_api_ie_LAEntryRangeAdd(void *pv_RefIEList, ST_IE_LA_ENTRY_RANGE *pst_EntryRange);
+E_CMBS_RC cmbs_api_ie_LAEntryRangeGet(void *pv_RefIE, ST_IE_LA_ENTRY_RANGE *pst_EntryRange);
+E_CMBS_RC cmbs_api_ie_LAEntryIdsAdd(void *pv_RefIEList, ST_IE_LA_ENTRY_IDS *pst_EntryIds);
+E_CMBS_RC cmbs_api_ie_LAEntryIdsGet(void *pv_RefIE, ST_IE_LA_ENTRY_IDS *pst_EntryIds);
+E_CMBS_RC cmbs_api_ie_LASearchCriteriaAdd( void * pv_RefIEList, ST_IE_LA_SEARCH_CRITERIA * pst_LASearchCriteria );
+E_CMBS_RC cmbs_api_ie_RegCloseReasonAdd( void * pv_RefIEList, ST_IE_REG_CLOSE_REASON * pst_Reg_Close_Reason );
+E_CMBS_RC cmbs_api_ie_UpdatedDeviceStateAdd(void *pv_RefIEList, ST_IE_UPDATED_DEVICE_STATE *st_DeviceState);
+E_CMBS_RC cmbs_api_ie_DeviceListStatusAdd(void *pv_RefIEList, ST_IE_DEVICE_LIST_STATUS *st_DevListStatus);
+
+E_CMBS_RC cmbs_api_ie_LAEntryIdAdd( void * pv_RefIE, u16 u16_LAEntryId );
+E_CMBS_RC cmbs_api_ie_LAEntryIndexAdd( void * pv_RefIE, u16 u16_LAEntryIndex );
+E_CMBS_RC cmbs_api_ie_LAEntryCountAdd( void * pv_RefIE, u16 u16_LAEntryCount );
+E_CMBS_RC cmbs_api_ie_LAIsLastAdd( void * pv_RefIE, u8 u8_LAIsLast );
+E_CMBS_RC cmbs_api_ie_LARejectReasonAdd( void * pv_RefIE, u8 u8_LARejectReason );
+E_CMBS_RC cmbs_api_ie_LARejectReasonGet( void * pv_RefIE, u8 * pu8_LARejectReason );
+E_CMBS_RC cmbs_api_ie_LANrOfEntriesAdd( void * pv_RefIE, u16 u16_LANrOfEntries );
+E_CMBS_RC cmbs_api_ie_LANrOfEntriesGet( void * pv_RefIE, u16 * pu16_LANrOfEntries );
+E_CMBS_RC cmbs_api_ie_LineSubtypeAdd( void * pv_RefIEList, u8 value );
+E_CMBS_RC cmbs_api_ie_LineSubtypeGet( void * pv_RefIE, u8 * value );
+E_CMBS_RC cmbs_api_ie_SuSubtypeAdd( void * pv_RefIEList, u8 value );
+E_CMBS_RC cmbs_api_ie_SuSubtypeGet( void * pv_RefIE, u8 * value );
+E_CMBS_RC cmbs_api_ie_NumOfUrlsAdd( void * pv_RefIEList, u8 value );
+E_CMBS_RC cmbs_api_ie_NumOfUrlsGet( void * pv_RefIE, u8 * value );
+E_CMBS_RC cmbs_api_ie_RejectReasonAdd( void * pv_RefIEList, u8 value );
+E_CMBS_RC cmbs_api_ie_RejectReasonGet( void * pv_RefIE, u8 * value );
+E_CMBS_RC cmbs_api_ie_SuotaAppIdAdd(void * pv_RefIE, u32 u32_SuotaAppId);
+E_CMBS_RC cmbs_api_ie_SuotaAppIdGet(void * pv_RefIE, u32 * u32_SuotaAppId);
+E_CMBS_RC cmbs_api_ie_SuotaSessionIdAdd(void * pv_RefIE, u32 u32_SuotaSessionId);
+E_CMBS_RC cmbs_api_ie_SuotaSessionIdGet(void * pv_RefIE, u32 * u32_SuotaSessionId);
+
+E_CMBS_RC cmbs_api_ie_HsPropEventAdd( void * pv_RefIEList, ST_IE_HS_PROP_EVENT * pst_Param );
+E_CMBS_RC cmbs_api_ie_HsPropEventGet( void * pv_RefIE, ST_IE_HS_PROP_EVENT * pst_Parameter );
+
+E_CMBS_RC cmbs_api_ie_SYPOSpecificationGet(void * pv_RefIE, ST_IE_SYPO_SPECIFICATION* pst_Parameter);
+E_CMBS_RC cmbs_api_ie_SYPOSpecificationAdd(void * pv_RefIE, ST_IE_SYPO_SPECIFICATION * pst_Parameter);
+
+E_CMBS_RC cmbs_api_ie_AFE_EndpointConnectionGet( void *pv_RefIE, ST_IE_AFE_ENDPOINTS_CONNECT *pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointConnectionAdd( void *pv_RefIE, ST_IE_AFE_ENDPOINTS_CONNECT *pst_Parameter  );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointGet( void *pv_RefIE, ST_IE_AFE_ENDPOINT *pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointAdd( void * pv_RefIE, ST_IE_AFE_ENDPOINT * pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointGainGet( void * pv_RefIE, ST_IE_AFE_ENDPOINT_GAIN *pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointGainAdd( void * pv_RefIE, ST_IE_AFE_ENDPOINT_GAIN * pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointGainDBGet( void * pv_RefIE, ST_IE_AFE_ENDPOINT_GAIN_DB * pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_EndpointGainDBAdd( void * pv_RefIE, ST_IE_AFE_ENDPOINT_GAIN_DB * pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_AUXMeasureSettingsGet( void * pv_RefIE, ST_IE_AFE_AUX_MEASUREMENT_SETTINGS* pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_AUXMeasureSettingsAdd( void * pv_RefIE, ST_IE_AFE_AUX_MEASUREMENT_SETTINGS* pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_AUXMeasureResultGet( void * pv_RefIE, ST_IE_AFE_AUX_MEASUREMENT_RESULT* pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_AUXMeasureResultAdd( void * pv_RefIE, ST_IE_AFE_AUX_MEASUREMENT_RESULT* pst_Parameter );
+E_CMBS_RC cmbs_api_ie_AFE_ResourceTypeAdd(void * pv_RefIE, u8 u8_ResourceType);
+E_CMBS_RC cmbs_api_ie_AFE_ResourceTypeGet(void * pv_RefIE, u8 * u8_ResourceType);
+E_CMBS_RC cmbs_api_ie_AFE_InstanceNumAdd(void * pv_RefIE, u8 u8_InstanceNum);
+E_CMBS_RC cmbs_api_ie_AFE_InstanceNumGet(void * pv_RefIE, u8 * u8_InstanceNum);
+E_CMBS_RC cmbs_api_ie_DHSGValueAdd(void * pv_RefIE, u8 u8_DHSGValue);
+E_CMBS_RC cmbs_api_ie_DHSGValueGet(void * pv_RefIE, u8 *u8_DHSGValue);
+E_CMBS_RC cmbs_api_ie_GPIOIDGet(void * pv_RefIE, PST_IE_GPIO_ID pst_GPIOID);
+E_CMBS_RC cmbs_api_ie_GPIOIDAdd(void * pv_RefIE, PST_IE_GPIO_ID st_GPIOID);
+E_CMBS_RC cmbs_api_ie_PWMIDAdd(void *pv_RefIE, PST_IE_PWM_ID st_PWMID);
+E_CMBS_RC cmbs_api_ie_PWMIDGet(void *pv_RefIE,PST_IE_PWM_ID pst_PWMID);
+E_CMBS_RC cmbs_api_ie_GPIOModeGet(void * pv_RefIE, u8 * u8_Mode);
+E_CMBS_RC cmbs_api_ie_GPIOModeAdd(void * pv_RefIE, u8  u8_Mode);
+E_CMBS_RC cmbs_api_ie_GPIOValueGet(void * pv_RefIE, u8 * u8_Value);
+E_CMBS_RC cmbs_api_ie_GPIOValueAdd(void * pv_RefIE, u8  u8_Value);
+E_CMBS_RC cmbs_api_ie_GPIOPullTypeGet(void * pv_RefIE, u8 * u8_PullType);
+E_CMBS_RC cmbs_api_ie_GPIOPullTypeAdd(void * pv_RefIE, u8 u8_PullType);
+E_CMBS_RC cmbs_api_ie_GPIOPullEnaGet(void * pv_RefIE, u8 * u8_PullEna);
+E_CMBS_RC cmbs_api_ie_GPIOPullEnaAdd(void * pv_RefIE, u8 u8_PullEna);
+E_CMBS_RC cmbs_api_ie_GPIOEnaGet(void * pv_RefIE, u8 * u8_Ena);
+E_CMBS_RC cmbs_api_ie_GPIOEnaAdd(void * pv_RefIE, u8 u8_Ena);
+E_CMBS_RC cmbs_api_ie_PWMEnaAdd(void *pv_RefIE, u8 u8_Ena);
+E_CMBS_RC cmbs_api_ie_PWMEnaGet(void *pv_RefIE, u8 *u8_Ena);
+E_CMBS_RC cmbs_api_ie_ExtIntNumGet(void * pv_RefIE, u8 * u8_IntNum);
+E_CMBS_RC cmbs_api_ie_ExtIntNumAdd(void * pv_RefIE, u8 u8_IntNum);
+E_CMBS_RC cmbs_api_ie_ExtIntConfigurationAdd(void * pv_RefIE, PST_IE_INT_CONFIGURATION st_INTConfiguration);
+E_CMBS_RC cmbs_api_ie_ExtIntConfigurationGet(void * pv_RefIE, PST_IE_INT_CONFIGURATION st_INTConfiguration);
+E_CMBS_RC cmbs_api_ie_TerminalCapabilitiesAdd(void * pv_RefIE, PST_IE_TERMINAL_CAPABILITIES pst_TermCapability);
+E_CMBS_RC cmbs_api_ie_TerminalCapabilitiesGet(void * pv_RefIE, PST_IE_TERMINAL_CAPABILITIES pst_TermCapability);
+E_CMBS_RC cmbs_api_ie_ChecksumErrorAdd( void * pv_RefIEList, PST_IE_CHECKSUM_ERROR  pst_CheckSumError);
+E_CMBS_RC cmbs_api_ie_ChecksumErrorGet( void * pv_RefIE, PST_IE_CHECKSUM_ERROR  pst_CheckSumError );
+E_CMBS_RC cmbs_api_ie_CallHoldReasonGet(void * pv_RefIE, PST_IE_CALL_HOLD_REASON pst_Reason);
+E_CMBS_RC cmbs_api_ie_CallHoldReasonAdd(void * pv_RefIE, PST_IE_CALL_HOLD_REASON pst_Reason);
+E_CMBS_RC cmbs_api_ie_SuotaFileInfoAdd(void *pv_RefIE, PST_IE_SUOTA_FILE_INFO pst_FileInfo);
+E_CMBS_RC cmbs_api_ie_SuotaFileInfoGet(void *pv_RefIE, PST_IE_SUOTA_FILE_INFO pst_FileInfo);
+E_CMBS_RC cmbs_api_ie_DTAMSessionIdAdd(void *pv_RefIE, u16 u16_SessionId);
+E_CMBS_RC cmbs_api_ie_DTAMSessionIdGet(void *pv_RefIE, u16 *u16_SessionId);
+E_CMBS_RC cmbs_api_ie_DTAMStartSessionCfmAdd(void *pv_RefIE, PST_CMBS_DTAM_START_SESSION_CFM pst_StartSessionCfm);
+E_CMBS_RC cmbs_api_ie_DTAMStartSessionCfmGet(void *pv_RefIE, PST_CMBS_DTAM_START_SESSION_CFM pst_StartSessionCfm);
+E_CMBS_RC cmbs_api_ie_DTAMCommandAdd(void *pv_RefIE, u8 u8_Command);
+E_CMBS_RC cmbs_api_ie_DTAMCommandGet(void *pv_RefIE, u8 *u8_Command);
+E_CMBS_RC cmbs_api_ie_DTAMCommandNackAdd(void *pv_RefIE, PST_CMBS_DTAM_NACK pst_CommandNack);
+E_CMBS_RC cmbs_api_ie_DTAMCommandNackGet(void *pv_RefIE, PST_CMBS_DTAM_NACK pst_CommandNack);
+E_CMBS_RC cmbs_api_ie_DTAMStatusAdd(void *pv_RefIE, PST_CMBS_DTAM_STATUS pst_DTAMStatus);
+E_CMBS_RC cmbs_api_ie_DTAMStatusGet(void *pv_RefIE, PST_CMBS_DTAM_STATUS pst_DTAMStatus);
+E_CMBS_RC cmbs_api_ie_DTAMSelectNextMsgAdd(void *pv_RefIE, u8 u8_Value);
+E_CMBS_RC cmbs_api_ie_DTAMSelectNextMsgGet(void *pv_RefIE, u8 *pu8_Value);
+E_CMBS_RC cmbs_api_ie_DTAMMsgTypeAdd(void *pv_RefIE, u8 u8_MsgType);
+E_CMBS_RC cmbs_api_ie_DTAMMsgTypeGet(void *pv_RefIE, u8 *pu8_MsgType);
+E_CMBS_RC cmbs_api_ie_DTAMMsgIdxGet(void *pv_RefIE, u8 *pu8_MsgIdx);
+E_CMBS_RC cmbs_api_ie_DTAMMsgIdxAdd(void *pv_RefIE, u8 u8_MsgIdx);
+E_CMBS_RC cmbs_api_ie_DTAMPlayModeAdd(void *pv_RefIE, u8 u8_PlayMode);
+E_CMBS_RC cmbs_api_ie_DTAMPlayModeGet(void *pv_RefIE, u8 *pu8_PlayMode);
+E_CMBS_RC cmbs_api_ie_DTAMNumOfSecAdd(void *pv_RefIE, u8 u8_NumOfSec);
+E_CMBS_RC cmbs_api_ie_DTAMNumOfSecGet(void *pv_RefIE, u8 *pu8_NumOfSec);
+E_CMBS_RC cmbs_api_ie_RSSIGet(void *pv_RefIE, u8 *u8_RSSI);
+E_CMBS_RC cmbs_api_ie_RSSIAdd(void *pv_RefIE, u8 u8_RSSI);
+E_CMBS_RC cmbs_api_ie_CallStateFilterGet(void *pv_RefIE, u8 *u8_FilterType);
+E_CMBS_RC cmbs_api_ie_CallStateFilterAdd(void *pv_RefIE, u8 u8_FilterType);
+E_CMBS_RC cmbs_api_ie_LineTestResultsGet(void *pv_RefIE, PST_IE_SLIC_LINE_TEST_RES pst_LineTestResults);
+E_CMBS_RC cmbs_api_ie_LineTestResultsAdd(void *pv_RefIE, PST_IE_SLIC_LINE_TEST_RES pst_LineTestResults);
+E_CMBS_RC cmbs_api_ie_NltCapTestResultsGet(void *pv_RefIE, PST_IE_SLIC_NLT_CAP_TEST_RES pst_NltCapTestResults);
+E_CMBS_RC cmbs_api_ie_NltCapTestResultsAdd(void *pv_RefIE, PST_IE_SLIC_NLT_CAP_TEST_RES pst_NltCapTestResults);
+E_CMBS_RC cmbs_api_ie_FxsHookStatusAdd(void *pv_RefIEList, ST_IE_FXS_HOOK_STATUS *pst_FxsHookStatus);
+E_CMBS_RC cmbs_api_ie_FxsHookStatusGet(void *pv_RefIE, ST_IE_FXS_HOOK_STATUS *pst_FxsHookStatus);
+E_CMBS_RC cmbs_api_ie_CallDirectionAdd(void *pv_RefIEList, ST_IE_CALL_DIRECTION *pst_CallDirection);
+E_CMBS_RC cmbs_api_ie_CallDirectionGet(void *pv_RefIE, ST_IE_CALL_DIRECTION *pst_CallDirection);
+E_CMBS_RC cmbs_api_ie_JEDECIdGet(void *pv_RefIE, PST_IE_CMBS_JEDEC_ID pst_JEDECid);
+E_CMBS_RC cmbs_api_ie_JEDECIdAdd(void *pv_RefIE, PST_IE_CMBS_JEDEC_ID pst_JEDECid);
+E_CMBS_RC cmbs_api_ie_DTMFToneDurAdd(void *pv_RefIE, u16 u16_ToneDur);
+E_CMBS_RC cmbs_api_ie_DTMFToneDurGet(void *pv_RefIE, u16 *pu16_ToneDur);
+E_CMBS_RC cmbs_api_ie_CallListAdd(void *pv_RefIEList, ST_IE_CALL_LIST *pst_CallList);
+E_CMBS_RC cmbs_api_ie_CallListGet(void *pv_RefIE, ST_IE_CALL_LIST *pst_CallList);
+E_CMBS_RC cmbs_api_ie_TDMSlotsAdd(void *pv_RefIEList, u32 u32_Slots);
+E_CMBS_RC cmbs_api_ie_TDMSlotsGet(void *pv_RefIEList, u32 *pu32_Slots);
+E_CMBS_RC cmbs_api_ie_DTMFToneToHSAdd(void *pv_RefIE, u16 u16_DTMFToneToHSMask);
+E_CMBS_RC cmbs_api_ie_DTMFToneToHSGet(void *pv_RefIE, u16 *pu16_DTMFToneToHSMask);
+E_CMBS_RC cmbs_api_ie_HSReleaseReasonAdd(void *pv_RefIEList, ST_IE_HS_RELEASE_REASON *pst_RelReason);
+E_CMBS_RC cmbs_api_ie_HSReleaseReasonGet(void *pv_RefIE, ST_IE_HS_RELEASE_REASON *pst_RelReason);
+E_CMBS_RC cmbs_api_ie_CrashDumpEnableStatusAdd(void *pv_RefIEList, PST_IE_CRASH_DUMP_ENABLE_STATUS pst_Enable);
+E_CMBS_RC cmbs_api_ie_CrashDumpEnableStatusGet(void *pv_RefIEList, PST_IE_CRASH_DUMP_ENABLE_STATUS pst_Enable);
+E_CMBS_RC cmbs_api_ie_PacketNumberAdd(void *pv_RefIEList, PST_IE_PACKET_NUMBER pst_PktNr);
+E_CMBS_RC cmbs_api_ie_PacketNumberGet(void *pv_RefIEList, PST_IE_PACKET_NUMBER pst_PktNr);
+
+E_CMBS_RC	cmbs_api_ie_CallScreeningAdd(void *pv_RefIE, PST_IE_CALL_SCREENING pst_CallScreening);
+E_CMBS_RC	cmbs_api_ie_CallScreeningGet(void *pv_RefIE, PST_IE_CALL_SCREENING pst_CallScreening);
+
+E_CMBS_RC cmbs_api_ie_ProductIDAdd(void *pv_RefIEList, PST_IE_PRODUCT_ID pst_ProductID);
+E_CMBS_RC cmbs_api_ie_ProductIDGet(void *pv_RefIEList, PST_IE_PRODUCT_ID pst_ProductID);
+E_CMBS_RC cmbs_api_ie_OPUSDataAdd(void *pv_RefIEList, u8 *pu8_OPUSData, u16 u16_OPUSData_Size);
+E_CMBS_RC cmbs_api_ie_OPUSDataGet(void *pv_RefIEList, u8 **ppu8_OPUSData, u16 *pu16_OPUSData_Size);
+
+// E_CMBS_RC cmbs_api_ie_CallDataAdd(void *pv_RefIEList, PST_IE_CALL_DATA pst_CallData, u8 u8_NR_OF_TERMINALS);
+// E_CMBS_RC cmbs_api_ie_CSMTableAdd(void *pv_RefIEList, PST_IE_CSM_TABLE pst_CSMTable, u8 u8_MAX_NUM_CSM_SESSIONS);
+// E_CMBS_RC cmbs_api_ie_LineSessionDataAdd(void *pv_RefIEList, PST_IE_LINE_SESSION_DATA pst_LineSessionData, u8 u8_MAX_NUM_LINE_SESSIONS);
+E_CMBS_RC cmbs_api_ie_CallDataAdd(void *pv_RefIEList, u8 *pst_CallData, u8 u8_NR_OF_TERMINALS);
+E_CMBS_RC cmbs_api_ie_CallDataGet(void *pv_RefIE, u8 *pst_CallData);
+E_CMBS_RC cmbs_api_ie_CallDataSizeGet(void *pv_RefIE, u16 *pu16_CallDataSize);
+E_CMBS_RC cmbs_api_ie_CSMTableAdd(void *pv_RefIEList, u8 *pst_CSMTable, u8 u8_MAX_NUM_CSM_SESSIONS);
+E_CMBS_RC cmbs_api_ie_CSMTableGet(void *pv_RefIE, u8 *pst_CSMTable);
+E_CMBS_RC cmbs_api_ie_CSMTableSizeGet(void *pv_RefIE, u16 *pu16_CSMTableSize);
+E_CMBS_RC cmbs_api_ie_LineSessionDataAdd(void *pv_RefIEList, u8 *pst_LineSessionData, u8 u8_MAX_NUM_LINE_SESSIONS);
+E_CMBS_RC cmbs_api_ie_LineSessionDataGet(void *pv_RefIE, u8 *pst_LineSessionData);
+E_CMBS_RC cmbs_api_ie_LineSessionDataSizeGet(void *pv_RefIE, u16 *pu16_LineSessionDataSize);
+E_CMBS_RC cmbs_api_ie_DebugInfoRequestAdd(void *pv_RefIE, u16 u16_RequestMask);
+E_CMBS_RC cmbs_api_ie_DebugInfoReqGet(void *pv_RefIE, u16 *pu16_InfoRequest);
+E_CMBS_RC cmbs_api_ie_CMBSAppLineAdd(void *pv_RefIEList, u8 *pst_CMBSAppLine, u8 u8_CMBS_APP_LINE_MAX);
+E_CMBS_RC cmbs_api_ie_CMBSAppLineGet(void *pv_RefIE, u8 *pst_CMBSAppLine);
+E_CMBS_RC cmbs_api_ie_CMBSAppLineSizeGet(void *pv_RefIE, u16 *pu16_CMBSAppLineSize);
+E_CMBS_RC cmbs_api_ie_TermLineSessionAdd(void *pv_RefIE, ST_IE_CALL_INFO *pst_CallInfo);
+E_CMBS_RC cmbs_api_ie_TermLineSessionGet(void *pv_RefIE, ST_IE_CALL_INFO *pst_CallInfo);
+E_CMBS_RC cmbs_api_ie_CallReconnectAdd(void *pv_RefIEList, u8 u8_CallReconnect);
+E_CMBS_RC cmbs_api_ie_PowerModeTypeGet (void *pv_RefIE, u8 *pu8_powerMode);
+E_CMBS_RC cmbs_api_ie_NumOfSlotsGet (void *pv_RefIE, u8 *pu8_NumOfSlots);
+E_CMBS_RC cmbs_api_ie_PowerModeResGet(void *pv_RefIE, u8 *u8_PowerModeRes);
+
+
+#endif

dectmngr/src/cmbs/cmbs_int.h

@@ -0,0 +1,322 @@
+/*!
+*  \file       cmbs_int.h
+*  \brief      This file contains internal structures and definitions of CMBS
+*
+*  \author     stein
+*
+*  @(#)  %filespec: cmbs_int.h~12.1.12 %
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================\n
+*  date        name     version   action                                          \n
+*  ----------------------------------------------------------------------------\n
+* 27-Jan-14 tcmc_asa  ---GIT-- change type of cmbs_int_SendChecksumError
+* 13-Jan-2014 tcmc_asa  -- GIT--  take checksum changes from 3.46.x to 3_x main (3.5x)
+* 20-Dec-13 tcmc_asa   GIT  Added CHECKSUM_SUPPORT    
+* 25-Feb-09    stein    61       Restructuration                             \n
+* 18-Feb-09    kelbch   3        add target build version to HOST API structure \n
+* 16-Feb-09    kelbch   2        Integration to host/target build\n
+*******************************************************************************/
+
+#if   !defined( CMBS_INT_H )
+#define  CMBS_INT_H
+
+#include "cmbs_api.h"               /* CMBS API definition */
+#include "cfr_ie.h"                 /* CMBS IE handling */
+#include "cfr_mssg.h"
+
+#if defined( __linux__ )
+	#include <pthread.h>
+	#include <unistd.h>
+#endif
+
+#ifdef WIN32
+	#include "windows.h"
+#endif
+
+/* Local definitions */
+#if defined(CHECKSUM_SUPPORT) && defined(CMBS_DEBUG)
+# define CHECKSUMPRINT(x) printf x
+#else
+# define CHECKSUMPRINT(x)
+#endif
+
+#if !defined ( CMBS_API_TARGET )
+#ifndef CMBS_NUM_OF_HOST_THREADS
+#define CMBS_NUM_OF_HOST_THREADS 8
+/* Current host threads:
+-1- Callback
+-2- HAN
+-3- UART
+-4- Reconnect (temporary thread)
+-5- SUOTA
+-6- Log
+-7- main
+-8- RESERVED/FUTURE
+*/
+#endif
+
+#define CMBS_UNKNOWN_THREAD 0xFF
+
+///////////////////////////
+
+
+#endif
+/*!
+   brief endianess
+*/
+typedef enum
+{
+   E_CMBS_ENDIAN_LITTLE,            /*!< little endian */
+   E_CMBS_ENDIAN_BIG,               /*!< big endian */
+   E_CMBS_ENDIAN_MIXED              /*!< mixed endian */
+} E_CMBS_ENDIAN;
+
+
+/*!
+   \brief return value of DnA CMBS framework
+*/
+typedef enum
+{
+   CFR_E_RETVAL_OK,                 /*!< successful return value*/
+   CFR_E_RETVAL_ERR,                /*!< general error occured */
+   CFR_E_RETVAL_ERR_MEM,            /*!< not enough memory available */
+
+} CFR_E_RETVAL;
+
+/*! currently default value of target module */
+
+#define  B0		0000000		/* hang up */
+#define  B50	0000001
+#define  B75	0000002
+#define  B110	0000003
+#define  B134	0000004
+#define  B150	0000005
+#define  B200	0000006
+#define  B300	0000007
+#define  B600	0000010
+#define  B1200	0000011
+#define  B1800	0000012
+#define  B2400	0000013
+#define  B4800	0000014
+#define  B9600	0000015
+#define  B19200	0000016
+#define  B38400	0000017
+
+#define  B57600   0010001
+#define  B115200  0010002
+#define  B230400  0010003
+#define  B460800  0010004
+#define  B500000  0010005
+#define  B576000  0010006
+#define  B921600  0010007
+#define  B1000000 0010010
+#define  B1152000 0010011
+#define  B1500000 0010012
+#define  B2000000 0010013
+#define  B2500000 0010014
+#define  B3000000 0010015
+#define  B3500000 0010016
+#define  B4000000 0010017
+
+
+/*!   \brief local application slot */
+typedef struct
+{
+   void *            pv_AppRefHandle;        /*!< store application reference pointer */
+   PFN_CMBS_API_CB   pFnAppCb;               /*!< store to be called function (reception of CMBS events)*/
+   ST_CB_LOG_BUFFER  pFnCbLogBuffer;         /*!< storage for callback of log buffer */
+   u16               u16_AppAPIVersion;      /*!< requested API version of application (further needed to get compatibility)*/
+#if defined ( CMBS_API_TARGET )
+   ST_CFR_IE_LIST    st_TransmitterIEList;   /*!< IE list of transmit direction */
+   u8                u8_IEBuffers[1][CMBS_BUF_SIZE];  /*!< 1 buffer of a complete IE list (one buffer for each thread, max. 1 thread) */
+#else
+   ST_CFR_IE_LIST    st_TransmitterIEList[CMBS_NUM_OF_HOST_THREADS];          /*!< IE list of transmit direction */
+   u8                u8_IEBuffers[CMBS_NUM_OF_HOST_THREADS][CMBS_BUF_SIZE];   /*!< 4 buffers of a complete IE list (one buffer for each thread, max. 4 threads) */
+   u32               u32_ThreadIdArray[CMBS_NUM_OF_HOST_THREADS];             /*!< Array to store thread id */
+#endif // defined ( CMBS_API_TARGET )
+} ST_CMBS_API_SLOT, * PST_CMBS_API_SLOT;
+
+/*!
+   brief enum of commuication flow control
+*/
+typedef enum
+{
+   E_CMBS_FLOW_STATE_GO,            /*!< transmitter/receiver works fine */
+   E_CMBS_FLOW_STATE_STOP,          /*!< transmitter/receiver is busy, no packet transmission*/
+   E_CMBS_FLOW_STATE_MAX
+} E_CMBS_FLOW_STATE;
+
+/*! \brief CMBS API Instance (local)*/
+typedef  struct
+{
+   ST_CMBS_API_SLOT  st_ApplSlot;
+   u16               u16_TargetVersion;      /*!< target CMBS API version */
+   E_CMBS_HW_CHIP    u8_HwChip;      		 /*!< HW chip */
+   E_CMBS_HW_COM_TYPE      u8_HwComType;     /*!< HW communication */
+   u32               u32_CallInstanceCount;
+//#if !defined ( CMBS_API_TARGET )
+   u16               u16_TargetBuild;        /*!< contains the build version of target side*/
+//#endif
+   E_CMBS_API_MODE   e_Mode;                 /*!< request CMBSMode */
+   E_CMBS_FLOW_STATE e_OrigFlowState;        /*!< Originator transmission state */
+   E_CMBS_FLOW_STATE e_DestFlowState;        /*!< Destination transmission state */
+   E_CMBS_ENDIAN     e_Endian;               /*!< endianess: 0 = little */
+#if defined( __linux__ )
+   E_CMBS_DEVTYPE    eDevCtlType;            /*!< control device type properties*/
+   int               fdDevCtl;               /*!< handle of such device */
+
+   E_CMBS_DEVTYPE    eDevMediaType;          /*!< media device type properties */
+
+   pthread_t         serialThreadId;         /*!< thread ID of serial pump */
+   pthread_t         callbThreadId;          /*!< thread ID of callback function */
+
+   pthread_mutex_t   cond_Mutex;
+   pthread_cond_t    cond_UnLock;
+
+   int               msgQId;                 /*!< message queue information*/
+#else
+# if defined ( WIN32 )
+	E_CMBS_DEVTYPE    eDevCtlType;            /*!< control device type properties*/
+	E_CMBS_DEVTYPE    eDevMediaType;          /*!< media device type properties */
+	HANDLE            h_InitBlock;            /*!< handle to wait until CMBS is connected */
+	HANDLE			  h_RecPath;			      /*!< handle of synchronization path */
+	HANDLE			  h_RecThread;	  	      /*!< handle of receive data collector thread */
+	DWORD			  dw_ThreadID;
+	BOOL			  bo_Run;
+# endif
+#endif
+
+   CFR_CMBS_CRITICALSECTION		h_CriticalSectionTransmission;  /*!< Critical section for transmission of packets */
+   CFR_CMBS_CRITICALSECTION		h_TxThreadCriticalSection;
+
+} ST_CMBS_API_INST, * PST_CMBS_API_INST;
+
+/*!
+   The following serialized message format shall be used:
+      0    1    2    3      4    5      6    7      8    9      10   11
+   | 0xda 0xda 0xda 0xda | 0xLO 0xHI | 0xLO 0xHI | 0xXX 0xYY | 0xLO 0xHI | parameter data
+          sync.             total len   packet nr.   command     param len
+*/
+#define  CMBS_SYNC_LENGTH  4              /*!< Synchronization size */
+#define  CMBS_SYNC          0xDADADADA    /*!< Synchronization value */
+
+#define  CMBS_RCV_STATE_IDLE    0
+#define  CMBS_RCV_STATE_SYNC    1
+#define  CMBS_RCV_STATE_DATA    2
+
+/*! \brief CMBS API Instance (local)*/
+
+
+/*! \brief Union representing a complete serial cmbs api message
+   the union uses to work on the message with byte or structure access */
+typedef  union
+{
+   char           serialBuf[sizeof(u32)+sizeof(ST_CMBS_SER_MSG)];
+   struct
+   {
+      u32         u32_Sync;
+      ST_CMBS_SER_MSG
+                  st_Msg;
+   }st_Data;
+} U_CMBS_SER_DATA, * PU_CMBS_SER_DATA;
+
+#if defined(__linux__)
+typedef  struct
+{
+   int            nLength;
+   u8             u8_Data[CMBS_BUF_SIZE + sizeof(u32)];
+} ST_CMBS_LIN_MSGDATA, * PST_CMBS_LIN_MSGDATA;
+
+typedef  struct
+{
+   long           msgType;
+   ST_CMBS_LIN_MSGDATA
+                  msgData;
+} ST_CMBS_LIN_MSG, * PST_CMBS_LIN_MSG;
+#endif
+
+#if defined( __cplusplus )
+extern "C"
+{
+#endif
+
+extern ST_CMBS_API_INST g_CMBSInstance;
+extern ST_CAPABLITIES   g_st_CMBSCapabilities;
+
+/*****************************************************************************
+ * CMBS API Internal functions
+ *****************************************************************************/
+
+E_CMBS_ENDIAN     cmbs_int_EndiannessGet( void );
+u16               cmbs_int_EndianCvt16( u16 u16_Value );
+u32               cmbs_int_EndianCvt32( u32 u32_Value );
+void              cmbs_int_HdrEndianCvt( ST_CMBS_SER_MSGHDR *pst_Hdr );
+
+// OS and environment dependent function
+E_CMBS_RC         cmbs_int_EnvCreate( E_CMBS_API_MODE e_Mode, ST_CMBS_DEV * pst_DevCtl, ST_CMBS_DEV * pst_DevMedia );
+E_CMBS_RC         cmbs_int_EnvDestroy( void );
+// start-up blocking function to wait until CMBS is available
+void              _cmbs_int_StartupBlockSignal( PST_CMBS_API_INST pst_CMBSInst );
+
+E_CMBS_RC		  cmbs_int_SendHello(ST_CMBS_DEV * pst_DevCtl, ST_CMBS_DEV * pst_DevMedia);
+E_CMBS_RC		  cmbs_int_SendRAMDumpStoreCmd(void);
+#if !defined( CMBS_API_TARGET )
+E_CMBS_RC		  cmbs_int_WaitForResponse(u32 u32_TimeoutMs);
+#endif
+
+void *            cmbs_int_RegisterCb( void * pv_AppRef, PFN_CMBS_API_CB pfn_api_Cb, u16 u16_bcdVersion );
+void              cmbs_int_RegisterLogBufferCb( void * pv_AppRef, PST_CB_LOG_BUFFER pfn_log_buffer_Cb );
+void              cmbs_int_UnregisterCb( void * pv_AppRefHandle );
+
+u16               cmbs_int_ModuleVersionGet( void );
+u16				  cmbs_int_ModuleVersionBuildGet( void );
+
+E_CMBS_RC         cmbs_int_EventSend( E_CMBS_EVENT_ID e_EventID, u8 *pBuf, u16 u16_Length );
+void              cmbs_int_EventReceive ( u8 * pu8_Mssg, u16 u16_Size );
+
+E_CMBS_RC         cmbs_int_ResponseSend( E_CMBS_EVENT_ID e_ID, E_CMBS_RESPONSE e_RSPCode );
+E_CMBS_RC         cmbs_int_ResponseWithCallInstanceSend(	E_CMBS_EVENT_ID e_ID, 
+															E_CMBS_RESPONSE e_RSPCode, 
+															u32 u32CallInstance);
+E_CMBS_RC         cmbs_int_RespWithCallInstChannelID(E_CMBS_EVENT_ID e_ID,
+                                                  E_CMBS_RESPONSE e_RSPCode,
+                                                  u32 u32CallInstance,
+                                                  PST_IE_MEDIA_CHANNEL st_MediaChannel);
+
+E_CMBS_RC         cmbs_int_RespWithChannelID(E_CMBS_EVENT_ID e_ID,
+                                                  E_CMBS_RESPONSE e_RSPCode,
+                                                  PST_IE_MEDIA_CHANNEL pst_MediaChannel);
+
+E_CMBS_RC         cmbs_int_cmd_Send( u8 u8_Cmd, u8 * pBuf, u16 u16_Length );
+void              cmbs_int_cmd_Dispatcher( u8 u8_Cmd, u8 * pu8_Buffer, u16 u16_Size );
+void              cmbs_int_cmd_ReceiveEarly ( u8 * pu8_buffer );
+void			  _cmbs_int_SuspendTxCommands( void );
+void			  _cmbs_int_SuspendTxCommandswithoutSendingRES( void );
+void			  _cmbs_int_ResumeTxCommands( void );
+void			  _cmbs_int_ResumeTxCommandswithoutSendingRES( void );
+void              cmbs_int_cmd_FlowRestartHandle ( u16 u16_Packet );
+void              cmbs_int_cmd_FlowNOKHandle ( u16 u16_Packet );
+u8                cmbs_int_cmd_FlowStateGet ( void );
+u32 			  cmbs_cmd_parser( CMBS_CMD id, u8* pu8_Buffer, u8* pu8_Buffer_parse, u32 u32_Pos);
+	
+#ifdef CHECKSUM_SUPPORT
+void      p_cmbs_int_CalcChecksum(u8 * pCheckSum, u8 * pBuf, u16 u16_Length);
+u8        p_cmbs_int_ChecksumVerify(u8 u8_Checksum[2],  u8 * pBuf, u16 u16_Length);
+E_CMBS_RC cmbs_int_SendChecksumError(E_CMBS_CHECKSUM_ERROR e_ErrorType, u16 u16_EventID);
+void      cmbs_int_SimulateChecksumError(char u8_ErrorType);
+#endif
+void cmbs_int_cmd_SendCapablities (void);
+void cmbs_int_cmd_SendCapablitiesReply (void);
+void cmbs_int_ParseDectMsg(u8 * buff, u8 u8_ILen, u8 u8_HandsetNumber);
+
+
+E_CMBS_RC         cmbs_int_ie_RingTypeGet( void * pv_RefIE, u32 * pu32_Value );
+#if defined( __cplusplus )
+}
+#endif
+
+#endif   // CMBS_INT_H
+
+// EOF

dectmngr/src/cmbs/cmbs_rtp.c

@@ -0,0 +1,98 @@
+/*!
+*   \file           cmbs_rtp.c
+*   \brief          CMBS RTP Extension
+*   \Author         Denis Matiukha
+*
+*   @(#)            cmbs_rtp.c~1
+*
+*******************************************************************************/
+
+#if defined(__arm)
+    #include "tclib.h"
+    #include "embedded.h"
+#else
+    #include <stdlib.h>
+    #include <stdio.h>
+    #include <string.h>
+#endif
+
+#include "cmbs_int.h"
+
+E_CMBS_RC   cmbs_rtp_SessionStart       ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTP_SESSION_START, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtp_SessionStop        ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTP_SESSION_STOP, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtp_SessionUpdate      ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTP_SESSION_UPDATE, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtcp_SessionStart      ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTCP_SESSION_START, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtcp_SessionStop       ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTCP_SESSION_STOP, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtp_SendDTMF           ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTP_SEND_DTMF, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtp_EnableFaxAudioProcessingMode   ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTP_ENABLE_FAX_AUDIO_PROCESSING_MODE, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC   cmbs_rtp_DisableFaxAudioProcessingMode  ( void * pv_AppRefHandle, void * pv_RefIEList )
+{
+   PST_CFR_IE_LIST  p_List = (PST_CFR_IE_LIST)pv_RefIEList;
+
+   UNUSED_PARAMETER( pv_AppRefHandle );
+
+   return cmbs_int_EventSend( CMBS_EV_RTP_DISABLE_FAX_AUDIO_PROCESSING_MODE, p_List->pu8_Buffer, p_List->u16_CurSize );
+}

dectmngr/src/cmbs/cmbs_suota.c

@@ -0,0 +1,180 @@
+/*!
+*	\file			cmbs_suota.c
+*	\brief
+*	\Author		stein
+*
+*	@(#)	%filespec: cmbs_suota.c~7 %
+*
+*******************************************************************************/
+#if defined(__arm)
+    #include "tclib.h"
+    #include "embedded.h"
+#else
+    #include <stdlib.h>
+    #include <stdio.h>
+    #include <string.h>
+#endif
+
+#include "cmbs_int.h"
+
+#define SUOTA_APPLICATION_ID	0x437
+
+//effi
+E_CMBS_RC cmbs_dsr_suota_Init(void *pv_AppRefHandle)
+{
+	PST_CFR_IE_LIST p_List;
+	PST_CFR_IE_LIST p_List2;
+	E_CMBS_EVENT_ID e_EventID;
+	ST_IE_DATA      st_Data;
+	char Buffer[4];
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+    
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	e_EventID = CMBS_EV_DSR_SUOTA_REG_CPLANE_CB;
+
+	// Add IEs
+	cmbs_api_ie_SuotaAppIdAdd(p_List, SUOTA_APPLICATION_ID);
+	cmbs_api_ie_SuotaSessionIdAdd(p_List, 0);
+	
+	st_Data.u16_DataLen = 0;
+	st_Data.pu8_Data = 0;
+	cmbs_api_ie_DataAdd(p_List, &st_Data);
+	
+	cmbs_int_EventSend(e_EventID, p_List->pu8_Buffer, p_List->u16_CurSize);
+
+	// app cb
+	p_List2 = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	e_EventID = CMBS_EV_DSR_SUOTA_REG_APP_CB;
+	memset(Buffer,0,4);
+
+	// Add IEs
+	cmbs_api_ie_SuotaAppIdAdd(p_List, SUOTA_APPLICATION_ID);
+	cmbs_api_ie_SuotaSessionIdAdd(p_List, 0);
+	
+	st_Data.u16_DataLen = 4;
+	st_Data.pu8_Data = (u8*)Buffer;
+	cmbs_api_ie_DataAdd(p_List, &st_Data);
+	
+	cmbs_int_EventSend(e_EventID, p_List2->pu8_Buffer, p_List2->u16_CurSize);
+	return 0;
+}
+
+E_CMBS_RC cmbs_dsr_suota_SendHSVersionAvail (void *pv_AppRefHandle, ST_SUOTA_UPGRADE_DETAILS  st_HSVerAvail, u16 u16_Handset, ST_VERSION_BUFFER* pst_SwVersion, u16 u16_RequestId)
+{
+	PST_CFR_IE_LIST    p_List;
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+    
+    UNUSED_PARAMETER( pv_AppRefHandle );
+
+	cmbs_api_ie_ShortValueAdd( p_List, u16_Handset, CMBS_IE_HANDSETS);
+	cmbs_api_ie_VersionAvailAdd(p_List, &st_HSVerAvail);
+	cmbs_api_ie_VersionBufferAdd( p_List, pst_SwVersion);
+    cmbs_api_ie_RequestIdAdd( p_List, u16_RequestId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_SUOTA_SEND_VERS_AVAIL, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC cmbs_dsr_suota_SendSWUpdateInd ( void *pv_AppRefHandle, u16 u16_Handset, E_SUOTA_SU_SubType enSubType, u16 u16_RequestId )
+{
+	PST_CFR_IE_LIST    p_List;
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+	
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+	cmbs_api_ie_ShortValueAdd( p_List, u16_Handset, CMBS_IE_HANDSETS);
+	cmbs_api_ie_ByteValueAdd(p_List,enSubType,CMBS_IE_SU_SUBTYPE);
+    cmbs_api_ie_RequestIdAdd( p_List, u16_RequestId );
+	return cmbs_int_EventSend( CMBS_EV_DSR_SUOTA_SEND_SW_UPD_IND, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC cmbs_dsr_suota_SendURL ( void *pv_AppRefHandle, u16 u16_Handset, u8   u8_URLToFollow, ST_URL_BUFFER* pst_Url, u16 u16_RequestId )
+{
+	PST_CFR_IE_LIST    p_List;
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+
+	cmbs_api_ie_ShortValueAdd( p_List, u16_Handset, CMBS_IE_HANDSETS);
+	cmbs_api_ie_ByteValueAdd(p_List,u8_URLToFollow,CMBS_IE_NUM_OF_URLS);
+	cmbs_api_ie_UrlAdd(p_List,pst_Url);
+    cmbs_api_ie_RequestIdAdd( p_List, u16_RequestId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_SUOTA_SEND_URL, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+E_CMBS_RC cmbs_dsr_suota_SendNack ( void *pv_AppRefHandle, u16 u16_Handset, E_SUOTA_RejectReason RejectReason, u16 u16_RequestId )
+{
+	PST_CFR_IE_LIST    p_List;
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+
+	cmbs_api_ie_ShortValueAdd( p_List, u16_Handset, CMBS_IE_HANDSETS);
+	cmbs_api_ie_ByteValueAdd(p_List,RejectReason,CMBS_IE_REJECT_REASON);
+    cmbs_api_ie_RequestIdAdd( p_List, u16_RequestId );
+
+	return cmbs_int_EventSend( CMBS_EV_DSR_SUOTA_SEND_NACK, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+
+E_CMBS_RC cmbs_dsr_suota_Unreg_App_CB(void)
+{
+    PST_CFR_IE_LIST    p_List;
+    p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+    return cmbs_int_EventSend(CMBS_EV_DSR_SUOTA_UNREG_APP_CB, p_List->pu8_Buffer, p_List->u16_CurSize); 
+}
+
+
+E_CMBS_RC cmbs_dsr_suota_Session_Close ( void *pv_AppRefHandle, u32 u32_SessionId )
+{
+    PST_CFR_IE_LIST    p_List;
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+
+	cmbs_api_ie_SuotaSessionIdAdd(p_List, u32_SessionId );
+	
+	return cmbs_int_EventSend( CMBS_EV_DSR_SUOTA_SESSION_CLOSE, p_List->pu8_Buffer, p_List->u16_CurSize );
+}
+
+
+E_CMBS_RC cmbs_dsr_suota_DataSend (void *pv_AppRefHandle, u32 u32_appId, u32 u32_SessionId,
+								   char *pSdu, u32 u32_SduLength,u16 u16_RequestId)
+{
+	PST_CFR_IE_LIST    	p_List;
+	ST_IE_DATA      	st_Data;
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+	cmbs_api_ie_RequestIdAdd( p_List, u16_RequestId );
+    cmbs_api_ie_SuotaAppIdAdd(p_List, u32_appId);
+	cmbs_api_ie_SuotaSessionIdAdd(p_List, u32_SessionId);
+	st_Data.u16_DataLen = u32_SduLength;
+	st_Data.pu8_Data    = (u8*)pSdu;
+	cmbs_api_ie_DataAdd( p_List, &st_Data );
+	return cmbs_int_EventSend(CMBS_EV_DSR_SUOTA_DATA_SEND, p_List->pu8_Buffer, p_List->u16_CurSize);
+}
+
+E_CMBS_RC cmbs_dsr_suota_ExtendedDataSend (void *pv_AppRefHandle, u32 u32_appId, u32 u32_SessionId,
+								   char *pSdu, u32 u32_SduLength,u16 u16_RequestId, PST_IE_SUOTA_FILE_INFO pst_FileInfo)
+{
+	PST_CFR_IE_LIST    	p_List;
+	ST_IE_DATA      	st_Data;
+	p_List = (PST_CFR_IE_LIST)cmbs_api_ie_GetList();
+
+    UNUSED_PARAMETER( pv_AppRefHandle );
+	cmbs_api_ie_RequestIdAdd( p_List, u16_RequestId );
+    cmbs_api_ie_SuotaAppIdAdd(p_List, u32_appId);
+	cmbs_api_ie_SuotaSessionIdAdd(p_List, u32_SessionId);
+	cmbs_api_ie_SuotaFileInfoAdd(p_List, pst_FileInfo);
+	st_Data.u16_DataLen = u32_SduLength;
+	st_Data.pu8_Data    = (u8*)pSdu;
+	cmbs_api_ie_DataAdd( p_List, &st_Data );
+	return cmbs_int_EventSend(CMBS_EV_DSR_SUOTA_DATA_SEND, p_List->pu8_Buffer, p_List->u16_CurSize);
+}
+
+
+/*---------[End Of File]---------------------------------------------------------------------------------------------------------------------------*/

dectmngr/src/cmbs/cmbs_util.c

@@ -0,0 +1,244 @@
+/*!
+*	\file		cmbs_util.c
+*	\brief		This file contains utility functions for CMBS API usage
+*	\Author		andriig 
+*
+*	@(#)	%filespec: cmbs_util.c~DMZD53#2.1.2 %
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================
+*  date        name     version   action                                          
+*  ---------------------------------------------------------------------------
+*
+* 17-Oct-14 tcmc_asa  ---GIT-- added CMBS_PARAM_INL_DEL
+* 30-Jul-2013 tcmc_asa --GIT-- added CMBS_PARAM_FP_CUSTOM_FEATURES(_LENGTH )
+*
+*******************************************************************************/
+
+#include "cmbs_util.h"
+#include "cfr_debug.h"
+
+u16 cmbs_util_GetParameterLength( E_CMBS_PARAM e_Param )
+{
+	switch ( e_Param )
+	{
+	case  CMBS_PARAM_RFPI:
+		return CMBS_PARAM_RFPI_LENGTH;
+	case  CMBS_PARAM_RVBG:
+		return CMBS_PARAM_RVBG_LENGTH;
+	case  CMBS_PARAM_RVREF:
+		return CMBS_PARAM_RVREF_LENGTH;
+	case  CMBS_PARAM_RXTUN:
+		return CMBS_PARAM_RXTUN_LENGTH;
+	case  CMBS_PARAM_MASTER_PIN:
+	case  CMBS_PARAM_AUTH_PIN:
+		return CMBS_PARAM_PIN_CODE_LENGTH;
+	case  CMBS_PARAM_COUNTRY:
+		return CMBS_PARAM_COUNTRY_LENGTH;
+	case  CMBS_PARAM_SIGNALTONE_DEFAULT:
+		return CMBS_PARAM_SIGNALTONE_LENGTH;
+	case  CMBS_PARAM_TEST_MODE:
+		return CMBS_PARAM_TEST_MODE_LENGTH;
+	case CMBS_PARAM_ECO_MODE:
+		return CMBS_PARAM_ECO_MODE_LENGTH;
+	case  CMBS_PARAM_AUTO_REGISTER:
+		return CMBS_PARAM_AUTO_REGISTER_LENGTH;
+	case  CMBS_PARAM_NTP:
+		return CMBS_PARAM_NTP_LENGTH;
+	case CMBS_PARAM_GFSK:
+		return CMBS_PARAM_GFSK_LENGTH;
+	case  CMBS_PARAM_RESET_ALL:
+		return CMBS_PARAM_RESET_ALL_LENGTH;
+	case CMBS_PARAM_SUBS_DATA:
+		return CMBS_PARAM_SUBS_DATA_LENGTH;
+	case  CMBS_PARAM_AUXBGPROG:
+		return CMBS_PARAM_AUXBGPROG_LENGTH;
+	case  CMBS_PARAM_AUXBGPROG_DIRECT:
+		return CMBS_PARAM_AUXBGPROG_DIRECT_LENGTH;
+	case  CMBS_PARAM_ADC_MEASUREMENT:
+		return CMBS_PARAM_ADC_MEASUREMENT_LENGTH;
+	case  CMBS_PARAM_PMU_MEASUREMENT:
+		return CMBS_PARAM_PMU_MEASUREMENT_LENGTH;
+	case  CMBS_PARAM_RSSI_VALUE:
+		return CMBS_PARAM_RSSI_VALUE_LENGTH;
+	case CMBS_PARAM_DECT_TYPE:
+		return CMBS_PARAM_DECT_TYPE_LENGTH;
+	case CMBS_PARAM_MAX_NUM_ACT_CALLS_PT:
+		return CMBS_PARAM_MAX_NUM_ACT_CALLS_PT_LENGTH;
+	case CMBS_PARAM_ANT_SWITCH_MASK:
+		return CMBS_PARAM_ANT_SWITCH_MASK_LENGTH;
+	case CMBS_PARAM_PORBGCFG:
+		return CMBS_PARAM_PORBGCFG_LENGTH;
+	case  CMBS_PARAM_BERFER_VALUE:
+		return CMBS_PARAM_BERFER_VALUE_LENGTH;
+	case  CMBS_PARAM_INBAND_COUNTRY:
+		return CMBS_PARAM_INBAND_COUNTRY_LENGTH;
+	case  CMBS_PARAM_FP_CUSTOM_FEATURES:
+		return CMBS_PARAM_FP_CUSTOM_FEATURES_LENGTH;
+	case CMBS_PARAM_HAN_DECT_SUB_DB_START:
+	case CMBS_PARAM_HAN_DECT_SUB_DB_END:
+	case CMBS_PARAM_HAN_ULE_SUB_DB_START:
+	case CMBS_PARAM_HAN_ULE_SUB_DB_END:
+	case CMBS_PARAM_HAN_FUN_SUB_DB_START:
+	case CMBS_PARAM_HAN_FUN_SUB_DB_END:
+	case CMBS_PARAM_HAN_FUN_GROUP_LIST_START:
+	case CMBS_PARAM_HAN_FUN_GROUP_LIST_END:
+	case CMBS_PARAM_HAN_FUN_GROUP_TABLE_START:
+	case CMBS_PARAM_HAN_FUN_GROUP_TABLE_END:
+	case CMBS_PARAM_HAN_ULE_BROADCAST_CONVERSION_TABLE_START:
+	case CMBS_PARAM_HAN_ULE_BROADCAST_CONVERSION_TABLE_END:
+		return CMBS_PARAM_HAN_DB_ADDR_LENGTH;
+	case CMBS_PARAM_HAN_ULE_NEXT_TPUI:
+		return CMBS_PARAM_HAN_ULE_NEXT_TPUI_LENGTH;
+	case CMBS_PARAM_DHSG_ENABLE:
+		return CMBS_PARAM_DHSG_ENABLE_LENGTH;
+	case CMBS_PARAM_PREAM_NORM:
+		return CMBS_PARAM_PREAM_NORM_LENGTH;
+	case CMBS_PARAM_RF_FULL_POWER:
+		return CMBS_PARAM_RF_FULL_POWER_LENGTH;
+	case CMBS_PARAM_RF_LOW_POWER:
+		return CMBS_PARAM_RF_LOW_POWER_LENGTH;
+	case CMBS_PARAM_RF_LOWEST_POWER:
+		return CMBS_PARAM_RF_LOWEST_POWER_LENGTH;
+	case CMBS_PARAM_RF19APU_MLSE:
+		return CMBS_PARAM_RF19APU_MLSE_LENGTH;
+	case CMBS_PARAM_RF19APU_KCALOVR:
+		return CMBS_PARAM_RF19APU_KCALOVR_LENGTH;
+	case CMBS_PARAM_RF19APU_KCALOVR_LINEAR:
+		return CMBS_PARAM_RF19APU_KCALOVR_LINEAR_LENGTH;
+	case CMBS_PARAM_RF19APU_SUPPORT_FCC:
+		return CMBS_PARAM_RF19APU_SUPPORT_FCC_LENGTH;
+	case CMBS_PARAM_RF19APU_DEVIATION:
+		return CMBS_PARAM_RF19APU_DEVIATION_LENGTH;
+	case CMBS_PARAM_RF19APU_PA2_COMP:
+		return CMBS_PARAM_RF19APU_PA2_COMP_LENGTH;
+	case CMBS_PARAM_RFIC_SELECTION:
+		return CMBS_PARAM_RFIC_SELECTION_LENGTH;
+	case CMBS_PARAM_MAX_USABLE_RSSI:
+		return CMBS_PARAM_MAX_USABLE_RSSI_LENGTH;
+	case CMBS_PARAM_LOWER_RSSI_LIMIT:
+		return CMBS_PARAM_LOWER_RSSI_LIMIT_LENGTH;
+	case CMBS_PARAM_PHS_SCAN_PARAM:
+		return CMBS_PARAM_PHS_SCAN_PARAM_LENGTH;
+	case CMBS_PARAM_JDECT_LEVEL1_M82:
+		return CMBS_PARAM_JDECT_LEVEL1_M82_LENGTH;
+	case CMBS_PARAM_JDECT_LEVEL2_M62:
+		return CMBS_PARAM_JDECT_LEVEL2_M62_LENGTH;
+	case CMBS_PARAM_AUXBGP_DCIN:
+		return CMBS_PARAM_AUXBGP_DCIN_LENGTH;
+	case CMBS_PARAM_AUXBGP_RESISTOR_FACTOR:
+		return CMBS_PARAM_AUXBGP_RESISTOR_FACTOR_LENGTH;
+	case CMBS_PARAM_DAC1_VOL:
+		return CMBS_PARAM_DAC_VOL_LENGTH;
+	case CMBS_PARAM_DAC2_VOL:
+		return CMBS_PARAM_DAC_VOL_LENGTH;
+	case CMBS_PARAM_INL_DEL:
+		return CMBS_PARAM_INL_DEL_LENGTH;
+	 case CMBS_PARAM_SYPO_GPIO:
+		return CMBS_PARAM_SYPO_GPIO_LENGTH;
+	 case CMBS_PARAM_SYPO_WAIT_FOR_SYNC:
+		return CMBS_PARAM_SYPO_WAIT_FOR_SYNC_LENGTH;
+	 case CMBS_PARAM_SYPO_MODE:
+		return CMBS_PARAM_SYPO_MODE_LENGTH;           
+	 case CMBS_PARAM_UART_DELAY_TIMER:
+		return CMBS_PARAM_UART_DELAY_TIMER_LENGTH;
+	 case CMBS_PARAM_MAX_TRANSFER_SIZE:
+		return CMBS_PARAM_MAX_TRANSFER_SIZE_LENGTH;
+	case CMBS_PARAM_IOM_TEST_MODE:
+		return CMBS_PARAM_IOM_TEST_MODE_LENGTH;
+	 case CMBS_PARAM_RING_ON_OFF:
+		return CMBS_PARAM_RING_ON_OFF_LENGTH;
+	 case CMBS_PARAM_NEMO_MODE:
+		return CMBS_PARAM_NEMO_MODE_LENGTH;
+	 case CMBS_PARAM_HS_CW_DISABLED:
+		return CMBS_PARAM_HS_CW_DISABLED_LENGTH;
+    case CMBS_PARAM_ENC_DISABLE:
+        return CMBS_PARAM_ENC_DISABLE_LENGTH;           
+	 case CMBS_PARAM_INL_ADD:
+		return CMBS_PARAM_INL_ADD_LENGTH;
+	 case CMBS_PARAM_BBD_UPDATE:
+		return CMBS_PARAM_BBD_UPDATE_LENGTH;
+	 case CMBS_PARAM_CLOCK_MASTER_EDIT:
+		return CMBS_PARAM_CLOCK_MASTER_EDIT_LENGTH;
+	 case CMBS_PARAM_FXS_CALLEE_REGRET_TIME:
+	 case CMBS_PARAM_FXS_FIRST_DIGIT_TIMER:
+	 case CMBS_PARAM_FXS_INTER_DIGIT_TIMER:
+	 case CMBS_PARAM_FXS_STAR_HASH_CON_TIMER:
+		return CMBS_PARAM_FXS_TIMER_LENGTH;
+	 case CMBS_PARAM_FXS_TONE_CONFIG:
+		return CMBS_PARAM_FXS_TONE_CONFIG_LENGTH;
+     case CMBS_PARAM_PREP_QSPI_FOR_HW_RESET:
+        return CMBS_PARAM_PREP_QSPI_FOR_HW_RESET_LENGTH;   	
+    case CMBS_PARAM_INT_START_CALL_TO_HOST:
+	      return CMBS_PARAM_INT_START_CALL_TO_HOST_LENGTH;
+	case CMBS_PARAM_SUBS_DATA_EX:
+		return CMBS_PARAM_SUBS_DATA_EX_LENGTH;
+	
+	case CMBS_PARAM_ULE_MULTICAST_ENC_PARAMS:
+		return CMBS_PARAM_ULE_MULTICAST_ENC_PARAMS_LENGTH;
+        
+    case CMBS_PARAM_NEMO_CONTROL:
+        return CMBS_PARAM_NEMO_CONTROL_LENGTH;    
+               
+    case CMBS_PARAM_REPEATER_TYPE:
+        return CMBS_PARAM_REPEATER_TYPE_LENGTH;           
+
+     case CMBS_PARAM_REPEATER_SUBS_START:
+        return CMBS_PARAM_REPEATER_SUBS_ADDR_LENGTH;           
+
+     case CMBS_PARAM_REPEATER_SUBS_END:
+        return CMBS_PARAM_REPEATER_SUBS_ADDR_LENGTH;           
+       
+    case CMBS_PARAM_TEST_FLAGS:
+        return CMBS_PARAM_TEST_FLAGS_LENGTH;     
+              
+    case CMBS_PARAM_CP_FEATURES:
+        return CMBS_PARAM_CP_FEATURES_LENGTH;      
+             
+    case CMBS_PARAM_SUBS_DATA_EX_EEP_SIZE:
+        return CMBS_PARAM_SUBS_DATA_EX_EEP_SIZE_LENGTH;     
+              
+	default:
+		break;
+
+	}
+
+	return CMBS_RC_ERROR_PARAMETER;
+}
+
+E_CMBS_RC   cmbs_util_ParameterValid( E_CMBS_PARAM e_Param, u16 u16_DataLen )
+{
+	// get parameter length
+	u16  u16_RequiredLength = cmbs_util_GetParameterLength(e_Param);
+
+	// Check parameter length
+	if ( !u16_RequiredLength || u16_DataLen != u16_RequiredLength )
+	{
+        if(e_Param != CMBS_PARAM_BBD_UPDATE) // CMBS_PARAM_BBD_UPDATE is a special case that we do not know the size in advance
+        {
+		CFR_DBG_ERROR( "Parameter ERROR: Length mismatch. Required:%d <-> Got:%d\n",
+			u16_RequiredLength, u16_DataLen );
+
+		return CMBS_RC_ERROR_PARAMETER;
+		}
+	}
+
+	return   CMBS_RC_OK;
+}
+
+bool cmbs_util_RawPayloadEvent( u16 u16_EventID )
+{
+	switch(u16_EventID)
+	{
+	case CMBS_EV_DSR_FW_UPD_START:
+	case CMBS_EV_DSR_FW_UPD_PACKETNEXT:
+	case CMBS_EV_DSR_FW_UPD_END:
+	case CMBS_EV_DEM_OPUS_DATA:
+		return TRUE;
+	default:
+		break;
+	}
+
+	return FALSE;
+}

dectmngr/src/cmbs/cmbs_util.h

@@ -0,0 +1,28 @@
+/*!
+*  \file       cmbs_util.h
+*  \brief      This file contains utility functions for CMBS API usage
+*  \author     andriig
+*
+*  @(#)  %filespec: cmbs_util.h~DMZD53#2 %
+*
+*******************************************************************************/
+
+#if   !defined( CMBS_UTIL_H )
+#define  CMBS_UTIL_H
+
+#include "cmbs_api.h"               /* CMBS API definition */
+
+
+#ifdef WIN32
+#define SleepMs(x) Sleep(x)
+#else
+#define SleepMs(x) usleep(1000*x)
+#endif
+
+
+
+u16			cmbs_util_GetParameterLength( E_CMBS_PARAM e_Param );
+E_CMBS_RC   cmbs_util_ParameterValid( E_CMBS_PARAM e_Param, u16 u16_DataLen );
+bool		cmbs_util_RawPayloadEvent( u16 u16_EventID );
+
+#endif

dectmngr/src/frame/cfr_ie.c

@@ -0,0 +1,389 @@
+/*!
+*  \file       cfr_ie.c
+*  \brief
+*  \Author     kelbch
+*
+*  @(#)  %filespec: cfr_ie.c~DMZD53#8 %
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================\n
+*  date        name     version   action                                          \n
+*  ----------------------------------------------------------------------------\n
+*******************************************************************************/
+
+#if defined(__arm)
+#include "tclib.h"
+#include "embedded.h"
+#else
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#endif
+
+#if defined( __linux__ )
+#include <pthread.h>
+#endif
+
+#include "cmbs_int.h"      /* internal API structure and defines */
+
+#if defined( CMBS_API_TARGET )
+#include "tapp_log.h"
+#endif
+
+#include "cfr_debug.h"     /* debug handling */
+
+#if !defined ( CMBS_API_TARGET )
+E_CMBS_RC cfr_ie_DeregisterThread(u32 u32_ThreadId)
+{
+    u8 u8_idx;
+    u8 u8_idx_max = sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers) / sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers[0]);
+
+    for (u8_idx = 0; u8_idx < u8_idx_max; ++u8_idx)
+    {
+        if ( g_CMBSInstance.st_ApplSlot.u32_ThreadIdArray[u8_idx] == u32_ThreadId )
+        {
+            // Current u8_idx represents the index of u8_IEBuffers
+            g_CMBSInstance.st_ApplSlot.u32_ThreadIdArray[u8_idx] = 0;
+            return CMBS_RC_OK;
+        }
+    }
+
+    // not found
+    return CMBS_RC_ERROR_PARAMETER;
+}
+
+u8 cfr_ie_getThreadIdx(void)
+{
+    u32     u32_CurrentThreadId;
+    u8      u8_idx;
+    u8      u8_idx_max = sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers) / sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers[0]);
+
+#if defined ( WIN32 )
+    u32_CurrentThreadId = (u32)GetCurrentThreadId();
+#endif // defined ( WIN32 )
+
+#if defined ( __linux__ )
+    u32_CurrentThreadId = (u32)pthread_self();
+#endif // defined ( __linux__ )
+
+    for (u8_idx = 0; u8_idx < u8_idx_max; ++u8_idx)
+    {
+        if ( g_CMBSInstance.st_ApplSlot.u32_ThreadIdArray[u8_idx] == u32_CurrentThreadId )
+        {
+            // Current u8_idx represents the index of u8_IEBuffers
+            break;
+        }
+    }
+
+    if ( u8_idx == u8_idx_max )
+    {
+        u8_idx = CMBS_UNKNOWN_THREAD;
+    }
+
+    return u8_idx;
+}
+
+
+u8 cfr_ie_AllocThreadIdx(void)
+{
+    u32     u32_CurrentThreadId;
+    u8      u8_idx;
+    u8      u8_idx_max = sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers) / sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers[0]);
+
+#if defined ( WIN32 )
+    u32_CurrentThreadId = (u32)GetCurrentThreadId();
+#endif // defined ( WIN32 )
+
+#if defined ( __linux__ )
+    u32_CurrentThreadId = (u32)pthread_self();
+#endif // defined ( __linux__ )
+
+    for ( u8_idx = 0; u8_idx < u8_idx_max; ++u8_idx )
+    {
+        if ( g_CMBSInstance.st_ApplSlot.u32_ThreadIdArray[u8_idx] == 0 )
+        {
+            // We found a free entry
+            g_CMBSInstance.st_ApplSlot.u32_ThreadIdArray[u8_idx] = u32_CurrentThreadId;
+            // CFR_DBG_OUT("New entry %d assign to thread id %d\n", u8_idx, u32_CurrentThreadId);
+            break;
+        }
+    }
+
+    if ( u8_idx == u8_idx_max )
+    {
+        u8_idx = CMBS_UNKNOWN_THREAD;
+    }
+
+    return u8_idx;
+}
+#endif
+
+void* cfr_ie_ListNew(u8 *pu8_Buffer, u16 u16_Size)
+{
+    PST_CFR_IE_LIST p_List;
+    u8 u8_idx;
+
+    if ( !u16_Size || !pu8_Buffer )
+    {
+#if defined ( CMBS_API_TARGET )
+        // When target, always use index 0
+        u8_idx = 0;
+        p_List = &g_CMBSInstance.st_ApplSlot.st_TransmitterIEList;
+        memset(p_List, 0, sizeof(ST_CFR_IE_LIST));
+#else
+        // Linux or WIN32 on host
+        u8_idx = cfr_ie_getThreadIdx(); 
+
+        if ( u8_idx == CMBS_UNKNOWN_THREAD ) 
+        {
+            // Try to allocate new entry for this thread
+            u8_idx = cfr_ie_AllocThreadIdx();
+
+            if ( u8_idx == CMBS_UNKNOWN_THREAD ) 
+            {
+                CFR_DBG_OUT("Not enough entries to store Thread Id !!!\n");
+                return NULL;
+            }
+        }
+        p_List = &g_CMBSInstance.st_ApplSlot.st_TransmitterIEList[u8_idx];
+        memset(p_List, 0, sizeof(ST_CFR_IE_LIST));
+#endif // defined ( CMBS_API_TARGET )
+
+        p_List->pu8_Buffer = g_CMBSInstance.st_ApplSlot.u8_IEBuffers[u8_idx];
+        p_List->u16_MaxSize = sizeof(g_CMBSInstance.st_ApplSlot.u8_IEBuffers[u8_idx]);
+
+        return p_List;
+    }
+    else
+    {
+        CFR_DBG_OUT("cfr_ie_ListNew: Dynamic is not implemented, yet\n");
+    }
+
+    return NULL;
+}
+
+int         cfr_ie_ItemAdd(PST_CFR_IE_LIST p_List, u8 *pu8_Buffer, u16 u16_Size)
+{
+    if ( p_List->u16_MaxSize > (u16_Size + p_List->u16_CurSize) )
+    {
+        memcpy(p_List->pu8_Buffer + p_List->u16_CurSize, pu8_Buffer, u16_Size);
+        p_List->u16_CurSize += u16_Size;
+
+        return 0;
+    }
+
+    CFR_DBG_ERROR("[ERROR] cfr_ie_ItemAdd MaxSize=%d u16_Size=%d u16_CurSize=%d", p_List->u16_MaxSize, u16_Size, p_List->u16_CurSize);
+
+    return -1;
+}
+
+u8*        cfr_ie_ItemGet(PST_CFR_IE_LIST p_List)
+{
+    // check if IE length is correct
+    if ( p_List->u16_CurSize - p_List->u16_CurIE < CFR_IE_HEADER_SIZE )
+        return NULL;
+
+    // return pointer to IE
+    return p_List->pu8_Buffer + p_List->u16_CurIE;
+}
+
+u8*        cfr_ie_ItemFirstGet(PST_CFR_IE_LIST p_List)
+{
+    // set current IE to first one
+    p_List->u16_CurIE = 0;
+
+    // return IE item
+    return cfr_ie_ItemGet(p_List);
+}
+
+u8*        cfr_ie_ItemNextGet(PST_CFR_IE_LIST p_List)
+{
+    u16      u16_NextIE = 0, u16_IESize = 0;
+
+    // 16 bit size
+    cfr_ie_dser_u16(p_List->pu8_Buffer + p_List->u16_CurIE + CFR_IE_SIZE_POS, &u16_IESize);
+
+    u16_NextIE = p_List->u16_CurIE  +  // start of current IE
+       CFR_IE_HEADER_SIZE +  // IE type 16 bit + IE length 16 bit
+       u16_IESize;           // size of current IE
+
+    if ( p_List->u16_CurSize > u16_NextIE )
+    {
+        p_List->u16_CurIE = u16_NextIE;
+
+        return cfr_ie_ItemGet(p_List);
+    }
+
+    return NULL;
+}
+
+u16            cfr_ie_ser_u8(u8 *pu8_Buffer, u8 u8_Value)
+{
+    if ( !pu8_Buffer )
+        return 0;
+
+    pu8_Buffer[0] = u8_Value;
+    return sizeof(u8);
+}
+
+u16            cfr_ie_ser_u16(u8 *pu8_Buffer, u16 u16_Value)
+{
+    u8 *pu8_16 = (u8 *)&u16_Value;
+
+    if ( !pu8_Buffer )
+        return 0;
+
+#if defined( CMBS_API_TARGET )
+    memcpy(pu8_Buffer, pu8_16, sizeof(u16_Value));
+#else                               // Host
+
+    if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_LITTLE )
+    {
+        memcpy(pu8_Buffer, &u16_Value, sizeof(u16_Value));
+    }
+    else
+    {
+        pu8_Buffer[0] = pu8_16[1];
+        pu8_Buffer[1] = pu8_16[0];
+    }
+#endif
+
+    return sizeof(u16_Value);
+}
+
+u16            cfr_ie_ser_u32(u8 *pu8_Buffer, u32 u32_Value)
+{
+    u8 *pu8_32 = (u8 *)&u32_Value;
+
+    if ( !pu8_Buffer )
+        return 0;
+
+#if defined( CMBS_API_TARGET )
+    memcpy(pu8_Buffer, pu8_32, sizeof(u32));
+#else                               // Host
+    if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_LITTLE )
+    {
+        memcpy(pu8_Buffer, &u32_Value, sizeof(u32));
+    }
+    else if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_BIG )
+    {
+        pu8_Buffer[0] = pu8_32[3];
+        pu8_Buffer[1] = pu8_32[2];
+        pu8_Buffer[2] = pu8_32[1];
+        pu8_Buffer[3] = pu8_32[0];
+    }
+    else if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_MIXED )
+    {
+        pu8_Buffer[0] = pu8_32[1];
+        pu8_Buffer[1] = pu8_32[0];
+        pu8_Buffer[2] = pu8_32[3];
+        pu8_Buffer[3] = pu8_32[2];
+    }
+    else
+    {
+        return 0;
+    }
+#endif
+
+    return sizeof(u32);
+}
+
+u16            cfr_ie_ser_pu8(u8 *pu8_Buffer, u8 *pu8_Data, u16 u16_DataSize)
+{
+    if ( !pu8_Data )
+        return 0;
+
+    memcpy(pu8_Buffer, pu8_Data, u16_DataSize);
+    return u16_DataSize;
+}
+
+
+u16 cfr_ie_dser_u8(u8 *pu8_Buffer, u8 *pu8_Value)
+{
+    if ( !pu8_Buffer || !pu8_Value )
+        return 0;
+
+    *pu8_Value = pu8_Buffer[0];
+    return sizeof(u8);
+}
+
+u16            cfr_ie_dser_u16(u8 *pu8_Buffer, u16 *pu16_Value)
+{
+    u8 *pu8_16 = (u8 *)pu16_Value;
+
+    if ( !pu8_Buffer || !pu16_Value )
+        return 0;
+
+#if defined( CMBS_API_TARGET )
+    pu8_16[1] = pu8_Buffer[1];
+    pu8_16[0] = pu8_Buffer[0];
+#else                               // Host
+    if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_LITTLE )
+    {
+        memcpy(pu8_16, pu8_Buffer, sizeof(u16));
+    }
+    else
+    {
+        pu8_16[1] = pu8_Buffer[0];
+        pu8_16[0] = pu8_Buffer[1];
+    }
+#endif
+
+    return sizeof(u16);
+}
+
+u16 cfr_ie_dser_s32(u8 *pu8_Buffer, s32 *ps32_Value)
+{
+    return cfr_ie_dser_u32(pu8_Buffer, (u32 *)ps32_Value);
+}
+
+
+u16            cfr_ie_dser_u32(u8 *pu8_Buffer, u32 *pu32_Value)
+{
+    u8 *pu8_32 = (u8 *)pu32_Value;
+
+    if ( !pu8_Buffer || !pu32_Value )
+        return 0;
+
+#if defined( CMBS_API_TARGET )
+    memcpy(pu8_32, pu8_Buffer, sizeof(u32));
+#else                               // Host
+    if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_LITTLE )
+    {
+        memcpy(pu8_32, pu8_Buffer, sizeof(u32));
+    }
+    else if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_BIG )
+    {
+        pu8_32[3] = pu8_Buffer[0];
+        pu8_32[2] = pu8_Buffer[1];
+        pu8_32[1] = pu8_Buffer[2];
+        pu8_32[0] = pu8_Buffer[3];
+    }
+    else if ( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_MIXED )
+    {
+        pu8_32[1] = pu8_Buffer[0];
+        pu8_32[0] = pu8_Buffer[1];
+        pu8_32[3] = pu8_Buffer[2];
+        pu8_32[2] = pu8_Buffer[3];
+    }
+    else
+    {
+        *pu32_Value = 0;
+        return 0;
+    }
+#endif
+
+    return sizeof(u32);
+}
+
+u16            cfr_ie_dser_pu8(u8 *pu8_Buffer, u8 *pu8_Data, u16 u16_DataSize)
+{
+    if ( !pu8_Buffer || !pu8_Data )
+        return 0;
+
+    memcpy(pu8_Data, pu8_Buffer, u16_DataSize);
+    return u16_DataSize;
+}
+
+//*/

dectmngr/src/frame/cfr_ie.h

@@ -0,0 +1,168 @@
+/*!
+*	\file			cfr_ie.h
+*	\brief
+*	\Author		kelbch
+*
+*	@(#)	%filespec: cfr_ie.h~DMZD53#6 %
+*
+*******************************************************************************
+*	\par	History
+*	\n==== History ============================================================\n
+*	date			name		version	 action                                          \n
+*	----------------------------------------------------------------------------\n
+*	27-05-14	ronenw		GIT		Added common ie for cmbs and han 
+*
+*******************************************************************************/
+
+#if	!defined( CFR_IE_H )
+#define	CFR_IE_H
+
+#include "cmbs_ie.h"
+#include "cmbs_han.h"
+
+#define		CFR_IE_TYPE_POS		0
+#define		CFR_IE_SIZE_POS		2
+#define		CFR_IE_HEADER_SIZE	4
+
+typedef struct
+{
+	u16		u16_MaxSize;
+	u16		u16_CurSize;
+	u16		u16_CurIE;
+	u8 *    pu8_Buffer;
+} ST_CFR_IE_LIST, * PST_CFR_IE_LIST;
+
+#define TEMP_SIZE (CMBS_PARAM_MAX_LENGTH+100)
+typedef union
+{
+	u8	u8_BufferByteValueAdd[CFR_IE_HEADER_SIZE + sizeof(u8)];
+	u8	u8_BufferShortValueAdd[CFR_IE_HEADER_SIZE + sizeof(u16)];
+	u8	u8_BufferByteU32ValueAdd[CFR_IE_HEADER_SIZE + sizeof(u32)];
+	u8 	u8_BufferReqAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALLTRANSFERREQ)];
+	u8  u8_BufferInternalReqAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_INTERNAL_TRANSFER)];
+	u8  u8_BufferCallerPartyAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALLERPARTY)+ CMBS_CALLER_NUM_MAX_LEN];
+	u8  u8_BufferCalledPartyAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALLEDPARTY)+ CMBS_CALLER_NUM_MAX_LEN];
+	u8  u8_BufferCallerNameAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALLINFO)+ TEMP_SIZE];
+	u8  u8_BufferCallInfoAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALLINFO)+ TEMP_SIZE];
+	u8  u8_BufferDisplayStringAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_DISPLAY_STRING)+ CMBS_DISPLAY_STRING_LENGTH];
+	u8  u8_BufferReleaseReasonAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_RELEASE_REASON)];
+	u8  u8_BufferCallStateAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALL_STATE)];
+	u8  u8_BufferChannelAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_MEDIA_CHANNEL)];
+	u8  u8_BufferAudioShmemAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_IE_AUDIO_SHMEM)];
+	u8  u8_BufferICAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_MEDIA_INTERNAL_CONNECT)];
+	u8  u8_BufferDescAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_MEDIA_DESCRIPTOR)];
+	u8  u8_BufferInfoAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_HANDSETINFO)];
+	u8  u8_BufferParameterAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_PARAMETER)+ TEMP_SIZE];
+	u8  u8_BufferHsListAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_SUBSCRIBED_HS_LIST)+ TEMP_SIZE];
+	u8  u8_BufferSettingsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_LINE_SETTINGS_LIST)];
+	u8  u8_BufferVersionAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_FW_VERSION)];
+	u8  u8_BufferLogAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_SYS_LOG)];
+	u8  u8_BufferAreaAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_PARAMETER_AREA)+ TEMP_SIZE];
+	u8  u8_BufferGenEventAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_GEN_EVENT)];
+	u8  u8_BufferPropEventAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_PARAMETER_AREA)+ TEMP_SIZE];
+	u8  u8_BufferDateAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_DATETIME)];
+	u8  u8_BufferSessionTypeAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_DATA_SESSION_TYPE)];
+	u8  u8_BufferDataAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_DATA)+ TEMP_SIZE];
+	u8  u8_BufferFieldsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_LA_FIELDS)];
+	u8  u8_BufferCriteriaAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_LA_SEARCH_CRITERIA)];
+	u8  u8_BufferATESettingsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_ATE_SETTINGS)];
+	u8  u8_BufferVersionAvailAdd[CFR_IE_HEADER_SIZE + sizeof(ST_SUOTA_UPGRADE_DETAILS)+ 1];// because of bit fields
+	u8  u8_BufferVersionBufAdd[CFR_IE_HEADER_SIZE + sizeof(ST_VERSION_BUFFER)];
+	u8  u8_BufferVersionIndAdd[CFR_IE_HEADER_SIZE + sizeof(ST_SUOTA_HS_VERSION_IND)];
+	u8  u8_BufferURLAdd[CFR_IE_HEADER_SIZE + sizeof(ST_URL_BUFFER)];
+	u8  u8_BufferChangeNotifAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_TARGET_LIST_CHANGE_NOTIF)];
+	u8  u8_BufferHwVersionAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_HW_VERSION)];
+	u8  u8_BufferDectSettingsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_DECT_SETTINGS_LIST)];
+	u8  u8_BufferPropSettingsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_PROP_FIELDS_LIST)];
+	u8  u8_BufferSessionInfoAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_RTP_SESSION_INFORMATION)];
+	u8  u8_BufferDTMFEventAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_RTP_DTMF_EVENT)];
+	u8  u8_BufferDTMFEventInfoAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_RTP_DTMF_EVENT_INFO)];
+	u8  u8_BufferPropCmdAdd[CFR_IE_HEADER_SIZE + sizeof(ST_LA_PROP_CMD)];
+	u8  u8_BufferBaseNameAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_BASE_NAME)];
+	u8  u8_BufferHsPropEventAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_HS_PROP_EVENT)+ TEMP_SIZE];
+	u8  u8_BufferSYPOSpecificationAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_SYPO_SPECIFICATION)];
+	u8  u8_BufferAFEEndpointConnectionAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_AFE_ENDPOINTS_CONNECT)];
+	u8  u8_BufferAFEEndpointAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_AFE_ENDPOINT)];
+	u8  u8_BufferAFEEndpointGainAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_AFE_ENDPOINT_GAIN)];
+	u8  u8_BufferAFEEndpointGainDBAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_AFE_ENDPOINT_GAIN)];
+	u8  u8_BufferAFEAUXMeasureSettingsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_AFE_AUX_MEASUREMENT_SETTINGS)];
+	u8  u8_BufferAFEAUXMeasureResultAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_AFE_AUX_MEASUREMENT_RESULT)];
+	u8  u8_BufferGPIOIDAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_GPIO_ID)];
+	u8  u8_BufferPWMIDAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_PWM_ID)];
+	u8  u8_BufferExtINTConfigAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_INT_CONFIGURATION)];
+	u8  u8_BufferTerminalCapabilitiesAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_TERMINAL_CAPABILITIES)];
+	u8  u8_BufferChecksumErrorAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CHECKSUM_ERROR)];
+	u8  u8_BuffeCallHoldReasonAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALL_HOLD_REASON)];
+	u8  u8_BufferCalledNameAdd[CFR_IE_HEADER_SIZE + 3 * sizeof(u8) + 2 * CMBS_CALLED_NAME_MAX_LEN];
+  u8  u8_BufferSuotaFileInfoAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_SUOTA_FILE_INFO)];
+  u8  u8_DTAMStartSessionCfmAdd[CFR_IE_HEADER_SIZE + sizeof(ST_CMBS_DTAM_START_SESSION_CFM)];
+  u8  u8_DTAMCommandNackAdd[CFR_IE_HEADER_SIZE + sizeof(ST_CMBS_DTAM_NACK)];
+  u8  u8_DTAMStatusAdd[CFR_IE_HEADER_SIZE + sizeof(ST_CMBS_DTAM_STATUS)];
+  u8  u8_BufferLineTestResultsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_SLIC_LINE_TEST_RES)];
+  u8  u8_BufferNltCapTestResultsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_SLIC_NLT_CAP_TEST_RES)];
+  u8  u8_BufferJEDECIdAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CMBS_JEDEC_ID)];
+  u8  u8_BufferUpdatedDeviceStateAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_UPDATED_DEVICE_STATE)];	
+  u8  u8_BufferCallListAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_CALL_LIST)+ TEMP_SIZE];	
+  u8 HanTableAdd[ CFR_IE_HEADER_SIZE + CMBS_HAN_IE_TABLE_SIZE];				// HAN part
+  u8 FunDeviceInfo[ CFR_IE_HEADER_SIZE + CMBS_HAN_IE_FUN_DEVICE_INFO_SIZE];
+  u8 BindRecordAdd[ CFR_IE_HEADER_SIZE + CMBS_HAN_IE_BIND_ENTRY_SIZE];
+  u8 GroupTableRecordAdd[ CFR_IE_HEADER_SIZE + CMBS_HAN_IE_GROUP_TABLE_ENTRY_SIZE];
+  u8 GroupListRecordAdd[ CFR_IE_HEADER_SIZE + CMBS_HAN_IE_GROUP_LIST_ENTRY_SIZE];
+  u8 RegInfoAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_HAN_MSG_REG_INFO)];
+  u8 HanMsgAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_IE_HAN_MSG) + CMBS_HAN_MAX_MSG_LEN];	
+  u8 UpdateInfoAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_IE_HAN_TABLE_UPDATE_INFO)];	
+  u8 Stage1ParamsAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_HAN_REG_STAGE_1_STATUS)];
+  u8 Stage2ParamsAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_HAN_REG_STAGE_2_STATUS)];
+  u8 HanBaseInfoAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_HAN_BASE_INFO)];
+  u8 UnknownDeviceParamsAdd[ CFR_IE_HEADER_SIZE + sizeof(ST_HAN_UNKNOWN_DEVICE_CONTACT_PARAMS)];
+  u8 HanFullRegistrationInfo[ CFR_IE_HEADER_SIZE + sizeof(ST_HAN_FULL_DEVICE_REGISTRATION_INFO)];
+  u8 HanULEDeviceIPUI[ CFR_IE_HEADER_SIZE + sizeof(ST_IE_HAN_ULE_DEVICE_IPUI)];
+  u8 HanULETBR6Statistics[ CFR_IE_HEADER_SIZE + sizeof(ST_IE_HAN_ULE_TBR6_STATISTICS)];
+  u8 u8_BufferDeviceListAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_DEVICE_LIST_STATUS)];	
+  u8 BufferHSRelReasonAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_HS_RELEASE_REASON)];
+  u8 u8_BufferEntryRageAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_LA_ENTRY_RANGE)];
+  u8 u8_BufferEntryIdsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_LA_ENTRY_IDS)];
+  u8 u8_BufferGenEventDetailsAdd[CFR_IE_HEADER_SIZE + sizeof(ST_IE_GEN_EVENT_DETAILS)];
+
+}
+U_Buffer;
+
+#if defined( __cplusplus )
+extern "C"
+{
+#endif
+
+void *         cfr_ie_ListNew( u8* pu8_Buffer, u16 u16_Size );
+int            cfr_ie_ItemAdd( PST_CFR_IE_LIST p_List, u8 * pu8_Buffer, u16 u16_Size );
+u8*            cfr_ie_ItemGet( PST_CFR_IE_LIST p_List );
+u8*            cfr_ie_ItemNextGet( PST_CFR_IE_LIST p_List );
+u8*            cfr_ie_ItemFirstGet ( PST_CFR_IE_LIST p_List );
+
+void           cfr_ie_Serialize( PST_CFR_IE_LIST p_List, E_CMBS_IE_TYPE e_IE, void * pv_Data );
+
+u16            cfr_ie_ser_pu8 ( u8 * pu8_buffer, u8 * pu8_Data, u16 u16_DataSize );
+u16            cfr_ie_ser_u8  ( u8 * pu8_Buffer, u8 u8_Value );
+u16            cfr_ie_ser_u16 ( u8 * pu8_buffer, u16  u16_Value );
+u16            cfr_ie_ser_u32 ( u8 * pu8_buffer, u32  u32_Value );
+
+u16            cfr_ie_dser_pu8 ( u8 * pu8_Buffer, u8  * pu8_Data, u16 u16_DataSize );
+u16            cfr_ie_dser_u8  ( u8 * pu8_Buffer, u8 * pu8_Value );
+u16            cfr_ie_dser_u16 ( u8 * pu8_Buffer, u16 * pu16_Value );
+u16            cfr_ie_dser_u32 ( u8 * pu8_Buffer, u32 * pu32_Value );
+u16            cfr_ie_dser_s32(u8 *pu8_Buffer, s32 *ps32_Value);
+
+E_CMBS_RC      cfr_ie_DeregisterThread (u32 u32_ThreadId);
+
+
+
+#if !defined ( CMBS_API_TARGET )
+u8          cfr_ie_getThreadIdx(void);
+u8          cfr_ie_AllocThreadIdx(void);
+#endif
+
+#if defined( __cplusplus )
+}
+#endif
+
+#endif	//	CFR_IE_H
+//*/

dectmngr/src/frame/linux/cfr_cmbs.c

@@ -0,0 +1,470 @@
+/*!
+*  \file       cfr_cmbs.c
+*  \brief      Target side
+*  \author     stein
+*
+*  @(#)  %filespec: cfr_cmbs.c~10 %
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================	\n
+*  date        name     version   action										\n
+*  ---------------------------------------------------------------------------	\n
+*  14-feb-09   R.Stein   1         Initialize									\n
+*  14-feb-09   D.Kelbch  2         Project integration - VONE					\n
+*  09-Apr-09   Kelbch    161       Update of Media Configuration during start-up\n
+*******************************************************************************/
+
+#include <syslog.h>
+
+#include "cmbs_platf.h"
+#include "cmbs_int.h"   /* internal API structure and defines */
+#include "cfr_uart.h"   /* packet handler */
+#ifdef CMBS_COMA
+#include "cfr_coma.h"   /* packet handler */
+#endif
+#include "cfr_debug.h"  /* debug handling */
+
+void  *           	_cmbs_int_CbThread( void * pVoid );
+void				cmbs_exit_callbThread(void);
+static 				int G_MsgQueue;
+
+volatile int g_WaitForResponseFlag = 0; 
+
+/* GLOBALS */
+ST_CMBS_API_INST  g_CMBSInstance;					// global CMBS instance object
+
+//		========== _cmbs_int_StartupBlockSignal ===========
+/*!
+	\brief			signal to block statement that CMBS is available
+	\param[in]		pst_CMBSInst		 pointer to CMBS instance object
+	\return			<none>
+*/
+void              _cmbs_int_StartupBlockSignal( PST_CMBS_API_INST pst_CMBSInst )
+{
+	// Update flag to CMBS host API, target available
+	g_WaitForResponseFlag = 1;
+}
+
+//		========== _cmbs_int_MsgQCreate ===========
+/*!
+	\brief				 Create a message queue
+	\param[in,out]		 < none >
+	\return				 < int > return identifier of queue. If there was an error, a value of -1 is returned.
+*/
+int               _cmbs_int_MsgQCreate( void )
+{
+	int            id = -1;
+
+	id = msgget( IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0666 );
+
+	if( id == -1 )
+	{
+		switch( errno )
+		{
+		case  EEXIST:
+			CFR_DBG_ERROR( "[ERROR]msgget, message queue exists (EEXIST)\n" );
+			break;
+
+		case  ENOMEM:
+			CFR_DBG_ERROR( "[ERROR]msgget, not enough memory (ENOMEM)\n" );
+			break;
+
+		case  ENOSPC:
+			CFR_DBG_ERROR( "[ERROR]msgget, max. number of queues (MSGMNI) exceeded\n" );
+			break;
+
+		default:
+			perror( "[ERROR]msgget" );
+		}
+	}
+
+	return id;
+}
+
+//		========== _cmbs_int_MsgQDestroy ===========
+/*!
+	\brief			   Destroy message queue
+	\param[in]  	   nMsgQId		   message queue identifier
+	\return			   < none >
+*/
+void              _cmbs_int_MsgQDestroy( int nMsgQId )
+{
+	if( msgctl(nMsgQId, IPC_RMID, 0) == -1 )
+	{
+		perror( "[ERROR]msgctl" );
+	}
+}
+
+//		========== cmbs_int_EnvCreate ===========
+/*!
+	\brief				build up the environment of CMBS-API. Open the relevant devices and starts the pumps.
+	\param[in,out]		e_Mode         to be used CMBS mode, currently only CMBS Multiline is supported
+	\param[in,out]		pst_DevCtl		pointer to device call control properties
+	\param[in,out]		pst_DevMedia	pointer to device media control properties
+	\return				< E_CMBS_RC >
+*/
+E_CMBS_RC         cmbs_int_EnvCreate( E_CMBS_API_MODE e_Mode, ST_CMBS_DEV * pst_DevCtl, ST_CMBS_DEV * pst_DevMedia )
+{
+	int	rc;
+
+	UNUSED_PARAMETER(pst_DevMedia);
+
+	openlog("cmbs_api.c", LOG_CONS | LOG_PID, LOG_NEWS);
+
+	memset( &g_CMBSInstance, 0, sizeof(g_CMBSInstance) );
+
+	// initialize the device control
+	if( !pst_DevCtl )
+	{
+		CFR_DBG_ERROR( "[ERROR] cmbs_int_EnvCreate: Device type is not specified\n");
+		return CMBS_RC_ERROR_PARAMETER;
+	}
+
+	pthread_cond_init( &g_CMBSInstance.cond_UnLock, NULL );
+	pthread_mutex_init( &g_CMBSInstance.cond_Mutex, NULL );
+
+	CFR_CMBS_INIT_CRITICALSECTION ( g_CMBSInstance.h_CriticalSectionTransmission );
+	CFR_CMBS_INIT_CRITICALSECTION ( g_CMBSInstance.h_TxThreadCriticalSection);
+
+	g_CMBSInstance.u32_CallInstanceCount = 0x80000000;
+	g_CMBSInstance.e_Mode		= e_Mode;  // useful later, if the API is connected to target side.
+	g_CMBSInstance.e_Endian		= cmbs_int_EndiannessGet();
+	g_CMBSInstance.eDevCtlType	= pst_DevCtl->e_DevType;
+	g_CMBSInstance.eDevMediaType= pst_DevMedia->e_DevType;
+
+	do 
+	{
+		// create message queue
+		if( (g_CMBSInstance.msgQId = _cmbs_int_MsgQCreate() ) == -1 )
+		{
+			CFR_DBG_ERROR( "cmbs_int_EnvCreate: ERROR creating message queue\n" );
+			break;
+		}
+
+		// initialize device configuration
+		if(pst_DevCtl->e_DevType == CMBS_DEVTYPE_UART)
+		{
+			g_CMBSInstance.fdDevCtl = cfr_uartInitialize( pst_DevCtl->u_Config.pUartCfg);
+		}
+		else if(pst_DevCtl->e_DevType == CMBS_DEVTYPE_USB)
+		{
+			g_CMBSInstance.fdDevCtl = cfr_usbInitialize( pst_DevCtl->u_Config.pUartCfg);
+		}
+#ifdef CMBS_COMA		
+		else if(pst_DevCtl->e_DevType == CMBS_DEVTYPE_COMA)
+		{
+			g_CMBSInstance.fdDevCtl = cfr_comaInitialize( pst_DevCtl->u_Config.pUartCfg);
+		}
+#endif		
+		else
+		{
+			CFR_DBG_ERROR( "[ERROR] cmbs_int_EnvCreate: Specified device type is not supported now\n");
+			break;
+		}
+
+		if( g_CMBSInstance.fdDevCtl == -1 )
+		{
+			CFR_DBG_ERROR( "[ERROR] cmbs_int_EnvCreate: Couldn't open Serial device\n" );
+			break;
+		}
+
+#ifdef CMBS_COMA
+		rc = pthread_create( &g_CMBSInstance.serialThreadId, NULL, & cfr_comaThread, &g_CMBSInstance );
+#else
+		rc = pthread_create( &g_CMBSInstance.serialThreadId, NULL, & cfr_uartThread, &g_CMBSInstance );
+#endif
+		if( rc != 0 )
+		{
+			CFR_DBG_ERROR( "[ERROR] cmbs_int_EnvCreate: Couldn't create Serial Thread. ErrorCode: %d\n", rc );
+			break;
+		}
+
+		// control device pipe is established, start control thread
+		rc = pthread_create( &g_CMBSInstance.callbThreadId, NULL, &_cmbs_int_CbThread, &g_CMBSInstance );
+		if( rc != 0 )
+		{
+			CFR_DBG_ERROR( "[ERROR] cmbs_int_EnvCreate: Couldn't create CB Thread. ErrorCode: %d\n", rc );
+			break;
+		}
+
+		return CMBS_RC_OK;
+
+	}while(FALSE);
+
+	CFR_CMBS_DELETE_CRITICALSECTION ( g_CMBSInstance.h_CriticalSectionTransmission );
+	CFR_CMBS_DELETE_CRITICALSECTION ( g_CMBSInstance.h_TxThreadCriticalSection );
+
+	return CMBS_RC_ERROR_GENERAL;
+}
+
+//		========== cmbs_int_WaitForResponse ===========
+/*!
+	\brief				Waits for target response using timeout in ms
+	\param[in,out]		u32_TimeoutMs   waiting timeout in ms
+	\return				< E_CMBS_RC >
+*/
+E_CMBS_RC cmbs_int_WaitForResponse(u32 u32_TimeoutMs)
+{
+	u32 u32_TimeoutSec = u32_TimeoutMs/1000;
+	u32 u32_numOfSec = 0;
+
+	while(u32_numOfSec < u32_TimeoutSec)
+	{
+		if(g_WaitForResponseFlag== 1)
+		{
+			g_WaitForResponseFlag = 0;
+			return CMBS_RC_OK;
+		}
+		u32_numOfSec++;
+		sleep(1);
+	}
+
+	CFR_DBG_ERROR( "[ERROR] cmbs_int_WaitForResponse: pthread_cond_timedwait returned error\n");
+
+	return   CMBS_RC_ERROR_OPERATION_TIMEOUT;
+}
+
+//		========== cmbs_int_EnvDestroy ===========
+/*!
+	\brief				 clean up the CMBS environment
+	\param[in,out]		 < none >
+	\return				< E_CMBS_RC >
+*/
+E_CMBS_RC         cmbs_int_EnvDestroy( void )
+{
+	// maybe we need to de-register on module side
+	if( g_CMBSInstance.serialThreadId )
+	{
+		pthread_cancel( g_CMBSInstance.serialThreadId );
+		pthread_join(g_CMBSInstance.serialThreadId, NULL);
+	}
+	if( g_CMBSInstance.callbThreadId )
+	{
+		cmbs_exit_callbThread();
+		pthread_join(g_CMBSInstance.callbThreadId, NULL);
+	}
+	pthread_cond_destroy( &g_CMBSInstance.cond_UnLock );
+	pthread_mutex_destroy( &g_CMBSInstance.cond_Mutex );
+
+	CFR_CMBS_DELETE_CRITICALSECTION ( g_CMBSInstance.h_CriticalSectionTransmission );
+	CFR_CMBS_DELETE_CRITICALSECTION ( g_CMBSInstance.h_TxThreadCriticalSection );
+
+	if( g_CMBSInstance.msgQId != -1 )
+		_cmbs_int_MsgQDestroy( g_CMBSInstance.msgQId );
+
+	close( g_CMBSInstance.fdDevCtl );
+
+	closelog();
+
+	return   CMBS_RC_OK;
+}
+
+void	cmbs_exit_callbThread(void)
+{
+	ST_CMBS_LIN_MSG LinMsg;
+
+	LinMsg.msgType = 2;
+	LinMsg.msgData.nLength = 4;	
+	LinMsg.msgData.u8_Data[0]  = 'E';
+	LinMsg.msgData.u8_Data[1]  = 'X';
+	LinMsg.msgData.u8_Data[2]  = 'I';
+	LinMsg.msgData.u8_Data[3]  = 'T';
+
+	if( msgsnd( G_MsgQueue, &LinMsg, (LinMsg.msgData.nLength + sizeof(LinMsg.msgData.nLength)), 0 ) < 0 )
+	{
+       	CFR_DBG_ERROR( "UartThread: msgsnd ERROR:%d\n", errno );
+    }
+
+}
+//		========== _cmbs_int_CbThread ===========
+/*!
+	\brief				 callback pump to receive and call application call-back
+	\param[in,out]		 pVoid		pointer to CMBS instance object
+	\return				< void * >  always NULL
+*/
+void  *           _cmbs_int_CbThread( void * pVoid )
+{
+	PST_CMBS_API_INST
+		pInstance = (PST_CMBS_API_INST)pVoid;
+	int            msgQId    = pInstance->msgQId;
+	int            nRetVal;
+	size_t         nMsgSize;
+	ST_CMBS_LIN_MSG
+		LinMsg;
+	U_CMBS_SER_DATA
+		CmbsMsg;
+	u32            u32_Sync = CMBS_SYNC;
+
+	static u32     nDataIndex = 0;
+
+	static bool		bNewMessage = TRUE;
+
+	G_MsgQueue = msgQId;
+	
+	nMsgSize = sizeof( LinMsg.msgData );
+
+	// never ending loop
+	// thread will be exited automatically when parent thread finishes
+	while( 1 )
+	{
+		/*
+		msgrcv() returns -1 if error.
+		
+		A signal can arrive and be handled while an I/O primitive such as msgrcv(), open() or read() is waiting for an I/O device.
+		When msgrcv() returned error of EINTR, it is means that this call did not succeed because it was interrupted.
+		However, if you try again, it will probably work.
+		
+		In other words, EINTR is not a fatal error - it just means you should retry msgrcv().
+		*/
+		nRetVal = msgrcv( msgQId, &LinMsg, nMsgSize, 0, 0);
+
+		if( nRetVal == -1 )
+		{
+			if (EINTR == errno)
+			{
+				return NULL;
+			}
+			CFR_DBG_ERROR( "[ERROR]CB Thread: !!!! msgrcv ERROR:%d\n", errno );
+		}
+		else
+		{
+			u32 i;
+			u32 LinMsgIndex = 0;
+
+			/*
+			CFR_DBG_OUT( "Received raw data %2d bytes:", LinMsg.msgData.nLength );
+			for( i = 0; i < (u32)LinMsg.msgData.nLength; i++ )
+			{
+			CFR_DBG_OUT( " %02X", LinMsg.msgData.u8_Data[i] );
+			}
+			CFR_DBG_OUT( "\n" );
+			*/
+			if (bNewMessage)
+			{
+				if( ( LinMsg.msgType == 2) &&
+					( LinMsg.msgData.nLength == 4 ) &&
+					( LinMsg.msgData.u8_Data[0] == 'E' ) &&
+					( LinMsg.msgData.u8_Data[1] == 'X' ) &&
+					( LinMsg.msgData.u8_Data[2] == 'I' ) &&
+					( LinMsg.msgData.u8_Data[3] == 'T' ))
+				{
+					CFR_DBG_OUT("--> EXIT message arrived to CbThread \n" );
+					return NULL;
+				}
+				
+				else
+
+				// If waiting for a new message, eliminate any non DA preceeding
+
+				for (i=0; i<(u32)LinMsg.msgData.nLength; i++)
+				{
+					if (LinMsg.msgData.u8_Data[i] != 0xDA)
+					{
+						LinMsgIndex++;
+					}
+					else
+					{
+						break;
+					}
+
+				}	
+
+
+				if (LinMsgIndex >0)
+				{
+					//shift arriving bytes to beginning of buffer (to start with DA)  
+					for (i=0; i<(u32)LinMsg.msgData.nLength - LinMsgIndex ; i++)
+					{
+						LinMsg.msgData.u8_Data[i] = LinMsg.msgData.u8_Data[LinMsgIndex + i]; 		
+					}
+					CFR_DBG_OUT("LinMsgIndex = %d \n",LinMsgIndex);
+					LinMsg.msgData.nLength -= LinMsgIndex;
+				}
+										
+				
+			}
+
+			
+		  if (LinMsg.msgData.nLength > 0) 
+		  {
+			// parse received message
+			for( i = 0; i < (u32)LinMsg.msgData.nLength; i++ )
+			{
+				if( nDataIndex == 0 )
+				{
+					memset( &CmbsMsg, 0, sizeof(CmbsMsg) );
+				}
+
+				// save message data
+				if( i < sizeof(CmbsMsg.serialBuf) )
+				{
+					CmbsMsg.serialBuf[nDataIndex] = LinMsg.msgData.u8_Data[i];
+					nDataIndex++;
+				}
+				else
+				{
+					CFR_DBG_ERROR( "[ERROR]CB Thread: !!!! msgrcv ERROR: buffer overflow\n" );
+					nDataIndex = 0;
+					break;
+				}
+
+				// validate syc dword
+				if((bNewMessage) && nDataIndex == sizeof(u32) )
+				{
+					if( memcmp( CmbsMsg.serialBuf, &u32_Sync, sizeof(u32)) == 0 )
+					{
+						// synch dword detected
+						bNewMessage = FALSE;
+					}
+					else
+					{
+						CFR_DBG_ERROR("CmbsMsg.serialBuf = %x %x %x %x \n",CmbsMsg.serialBuf[0],CmbsMsg.serialBuf[1],CmbsMsg.serialBuf[2],CmbsMsg.serialBuf[3]);
+						CFR_DBG_ERROR( "[ERROR]CB Thread: !!!! msgrcv ERROR: NO sync word detected\n" );
+						nDataIndex = 0;
+						break;
+					}
+				}
+
+				// check cmbs message length
+				if( nDataIndex >= sizeof(u32) + sizeof(u16) ) // sizeof(u32_Sync) + sizeof(u16_TotalLength)
+				{
+					u16 u16_Total ;
+
+					if( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_BIG )
+					{
+						u16_Total = cmbs_int_EndianCvt16(CmbsMsg.st_Data.st_Msg.st_MsgHdr.u16_TotalLength);
+					}
+					else
+					{
+						u16_Total = CmbsMsg.st_Data.st_Msg.st_MsgHdr.u16_TotalLength;
+					}
+
+					if( nDataIndex == sizeof(CmbsMsg.st_Data.u32_Sync) + u16_Total )
+					{
+						// we assume that cmbs message is complete
+						if( g_CMBSInstance.e_Endian == E_CMBS_ENDIAN_BIG )
+						{
+							cmbs_int_HdrEndianCvt( &CmbsMsg.st_Data.st_Msg.st_MsgHdr );
+						}
+
+						if( g_CMBSInstance.st_ApplSlot.pFnCbLogBuffer.pfn_cmbs_api_log_incoming_packet_write_finish_cb != NULL )
+						{
+							g_CMBSInstance.st_ApplSlot.pFnCbLogBuffer.pfn_cmbs_api_log_incoming_packet_write_finish_cb((u8 *)&CmbsMsg.st_Data.st_Msg, CmbsMsg.st_Data.st_Msg.st_MsgHdr.u16_TotalLength);
+						}
+
+						cmbs_int_EventReceive( (u8 *)&CmbsMsg.st_Data.st_Msg, CmbsMsg.st_Data.st_Msg.st_MsgHdr.u16_TotalLength );
+						// reset; we might have received more than one cmbs message
+						nDataIndex = 0;
+						bNewMessage = TRUE;
+					}
+				}
+			}
+		  }
+		}
+	}
+
+	return NULL;
+}
+
+//*/

dectmngr/src/frame/linux/cfr_coma.h

@@ -0,0 +1,36 @@
+/*!
+*  \file       cfr_coma.h
+*  \brief	   
+*  \author 
+*******************************************************************************/
+
+#if   !defined( CFR_COMA_H )
+#define  CFR_COMA_H
+#include "cmbs_int.h"
+/*! current packet transmission size */
+#define     CFR_BUFFER_WINDOW_SIZE  3
+
+/*! identifier for receive path */
+#define		CFR_BUFFER_COMA_REC		0
+/*! identifier for transmit path */
+#define		CFR_BUFFER_COMA_TRANS	1
+
+#if defined( __cplusplus )
+extern "C"
+{
+#endif
+void  *      cfr_comaThread( void * pVoid );
+int          cfr_comaInitialize( void *p );
+int			 cfr_comaPacketPartWrite( u8* pu8_Buffer, u16 u16_Size );
+void         cfr_comaPacketWriteFinish( u8 u8_BufferIDX );
+CFR_E_RETVAL cfr_comaPacketPrepare ( u16 u16_size );
+void		 cfr_comaDataTransmitKick ( void );
+void         cfr_comaStop(void);
+
+#if defined( __cplusplus )
+}
+#endif
+
+#endif   // CFR_COMA_H
+//*/
+

dectmngr/src/frame/linux/cfr_uart.c

@@ -0,0 +1,482 @@
+/*!
+*  \file       cfr_uart.c
+*  \brief      UART implementation of linux host side
+*  \author     stein
+*
+*  @(#)  %filespec: cfr_uart.c~DMZD53#4.1.2 %
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================\n
+*  date        name     version   action                                          \n
+*  ----------------------------------------------------------------------------\n
+*  14-feb-09   R.Stein    1         Initialize \n
+*******************************************************************************/
+
+#include <stdlib.h>
+#include <stddef.h>  // for offsetof
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <string.h>
+#include <sys/time.h> // we need <sys/select.h>; should be included in <sys/types.h> ???
+#include <pthread.h>
+#include <sys/ipc.h>
+#include <sys/msg.h>
+#include <errno.h>
+
+#include "cmbs_int.h"   /* internal API structure and defines */
+#include "cfr_uart.h"   /* packet handler */
+#include "cfr_debug.h"  /* debug handling */
+
+//    ========== cfr_uartThread ===========
+/*!
+      \brief            UART data receive pump. if data is available a message is send
+                        to cfr_cmbs task.
+
+      \param[in]        pVoid          pointer to CMBS instance object
+
+      \return           <void *>       return always NULL
+
+*/
+
+void  *           cfr_uartThread( void * pVoid )
+{
+   PST_CMBS_API_INST
+                  pInstance = (PST_CMBS_API_INST)pVoid;
+   int            fdDevCtl  = pInstance->fdDevCtl;
+   int            msgQId    = pInstance->msgQId;
+   fd_set         input_fdset;
+	ST_CMBS_LIN_MSG LinMsg;
+	int retval;
+
+//   CFR_DBG_OUT( "UART Thread: ID:%lu running\n", (unsigned long)pthread_self() );
+
+	/* 
+	Never ending loop.
+      Thread will be exited automatically when parent thread finishes.
+   */
+   while( 1 )
+   {
+      FD_ZERO( &input_fdset );
+      FD_SET( fdDevCtl, &input_fdset);
+
+		/*
+		select() returns 0 if timeout, 1 if input available, -1 if error.
+		
+		A signal can arrive and be handled while an I/O primitive such as select(), open() or read() is waiting for an I/O device.
+		When select() returned error of EINTR, it is means that this call did not succeed because it was interrupted.
+		However, if you try again, it will probably work.
+		
+		In other words, EINTR is not a fatal error - it just means you should retry select().
+		*/
+		retval = select(fdDevCtl+1, &input_fdset, NULL, NULL, NULL);
+		if (-1 == retval)
+		{
+			if (EINTR == errno)
+      {
+				return NULL;
+			}
+			
+			CFR_DBG_ERROR( "UartThread Error: select() failed with error %d\n",errno );
+       /*!\todo exception handling is needed !*/
+      }
+		else if (0 == retval)
+		{
+			CFR_DBG_ERROR( "UartThread Error: select() failed on timeout error\n");
+		}
+      else
+      {
+         if( FD_ISSET(fdDevCtl, &input_fdset) )
+         {
+            //memset( &LinMsg.msgData, 0, sizeof(LinMsg.msgData) );
+
+            /* Reading available data from serial interface */
+            if( (LinMsg.msgData.nLength = read(fdDevCtl, LinMsg.msgData.u8_Data, sizeof(LinMsg.msgData.u8_Data))) <= 0 )
+            {
+				CFR_DBG_ERROR( "UartThread Error: read() failed len=%d\n", LinMsg.msgData.nLength);
+
+#if SU_XHOST
+#if SU_XHOST_USB
+				// Detected disconnection of USB, sending CMBS_EV_DSR_TARGET_UP message to try and reconnect
+				LinMsg.msgType = 1;
+				LinMsg.msgData.nLength = 12;
+				LinMsg.msgData.u8_Data[0] = 0xDA;
+				LinMsg.msgData.u8_Data[1] = 0xDA;
+				LinMsg.msgData.u8_Data[2] = 0xDA;
+				LinMsg.msgData.u8_Data[3] = 0xDA;
+				LinMsg.msgData.u8_Data[4] = 0x08;
+				LinMsg.msgData.u8_Data[5] = 0x00;
+				LinMsg.msgData.u8_Data[6] = 0x00;
+				LinMsg.msgData.u8_Data[7] = 0x00;
+				LinMsg.msgData.u8_Data[8] = 0x7D;
+				LinMsg.msgData.u8_Data[9] = 0x00;
+				LinMsg.msgData.u8_Data[10] = 0x00;
+				LinMsg.msgData.u8_Data[11] = 0x00;
+
+				if( msgsnd( msgQId, &LinMsg, (LinMsg.msgData.nLength + sizeof(LinMsg.msgData.nLength)), 0 ) < 0 )
+				{
+			       	CFR_DBG_ERROR( "UartThread Error: reconnect msgsnd ERROR:%d\n", errno );
+			    }
+				return NULL;
+#endif
+#endif //SU_XHOST
+
+            }
+            else
+            {
+//               CFR_DBG_OUT( "UartThread: received %d bytes\n", LinMsg.msgData.nLength );
+
+               /* Send what we received to callback thread */
+               if( msgQId >= 0 )
+               {
+                  LinMsg.msgType = 1;
+//                  CFR_DBG_OUT( "UartThread: sent %d bytes\n", LinMsg.msgData.nLength + 4 );
+                  if( msgsnd( msgQId, &LinMsg, (LinMsg.msgData.nLength + sizeof(LinMsg.msgData.nLength)), 0 ) < 0 )
+                  {
+                     CFR_DBG_ERROR( "UartThread: msgsnd ERROR:%d\n", errno );
+                  }
+                  else
+                  {
+//                     CFR_DBG_OUT( "UartThread: msgsnd sent ok.\n");
+                  }
+               }
+               else
+               {
+                  CFR_DBG_ERROR( "UartThread: invalid msgQId:%d\n", msgQId );
+               }
+            }
+         }
+      }
+   }
+
+   return NULL;
+}
+
+
+//    ==========    cfr_wait_till_characters_transmitted ===========
+/*!
+      \brief             Wait till characters are transmitted
+
+      \param[in,out]     fd    pointer to packet part
+
+      \return            < none >
+
+*/
+
+void cfr_uartWaitPacketPartTransmitFinished(int fd)
+{
+   int rv;
+   fd_set writefds;
+
+   while(1)
+   {
+      FD_ZERO(&writefds);
+      FD_SET(fd, &writefds);
+
+      rv=select(fd+1, NULL, &writefds, NULL, NULL);
+
+      if (rv >= 0) break;
+      if (errno != EINTR) break;
+   }
+}
+
+//    ==========    cfr_uartPacketPartWrite ===========
+/*!
+      \brief             write partly the packet into communication device
+
+      \param[in,out]     pu8_Buffer    pointer to packet part
+
+      \param[in,out]     u16_Size      size of packet part
+
+      \return            < int >       currently, alway 0
+
+*/
+
+int               cfr_uartPacketPartWrite( u8* pu8_Buffer, u16 u16_Size  )
+{
+   // int    i;
+
+   // CFR_DBG_OUT( "PacketPartWrite: " );
+   // for (i=0; i < u16_Size; i++ )
+   // {
+   //   CFR_DBG_OUT( "%02x ",pu8_Buffer[i] );
+   //   write( g_CMBSInstance.fdDevCtl, pu8_Buffer + i, 1 );
+   // }
+   // CFR_DBG_OUT( "\n" );
+
+   write( g_CMBSInstance.fdDevCtl, pu8_Buffer, u16_Size);
+
+   cfr_uartWaitPacketPartTransmitFinished(g_CMBSInstance.fdDevCtl);
+
+   return 0;
+}
+//    ========== cfr_uartPacketWriteFinish ===========
+/*!
+      \brief             Currently dummy function is not needed on host side
+
+      \param[in,out]     u8_BufferIDX  buffer index
+
+      \return            < none >
+
+*/
+
+void              cfr_uartPacketWriteFinish( u8 u8_BufferIDX )
+{
+   // For logging sent data packets
+   UNUSED_PARAMETER(u8_BufferIDX);   
+}
+
+//    ========== cfr_uartPacketPrepare  ===========
+/*!
+      \brief             Currently dummy function is not needed on host side
+
+      \param[in,out]     u16_size      size of to be submitted packet for transmission
+
+      \return           < CFR_E_RETVAL >
+
+*/
+
+CFR_E_RETVAL      cfr_uartPacketPrepare( u16 u16_size )
+{
+   // dummy function
+   UNUSED_PARAMETER(u16_size);
+   
+   return CFR_E_RETVAL_OK;
+}
+
+//    ========== cfr_uartDataTransmitKick  ===========
+/*!
+      \brief             Currently dummy function is not needed on host side
+
+      \param[in,out]     < none >
+
+      \return           < CFR_E_RETVAL >
+
+*/
+
+void              cfr_uartDataTransmitKick( void )
+{
+   // dummy function
+}
+
+//    ========== cfr_uartInitialize ===========
+/*!
+      \brief             open the serial communication interface with relevant parameter sets
+
+      \param[in,out]     pst_Config    pointer to UART configuration
+
+      \return           < int >        if failed returns -1, otherwise 0
+
+*/
+
+int          cfr_uartInitialize( PST_UART_CONFIG pst_Config )
+{
+   char           szDevName[128] = {0};
+   int            fd;
+   struct termios term_attr;
+   unsigned int baud = B115200; /* defaults */
+   // generate device name
+   if( pst_Config->psz_ComDevName )
+   {
+      sprintf( szDevName, "/dev/%s", pst_Config->psz_ComDevName );
+   }
+   else if( pst_Config->u8_Port < 1 )
+   {
+//      CFR_DBG_WARN( "Warning: Invalid port COM%d. Using default COM1\n", pst_Config->u8_Port );
+      sprintf( szDevName, "/dev/ttyS0" );
+   }
+   else
+   {
+     sprintf( szDevName, "/dev/ttyS%d", pst_Config->u8_Port );
+   }
+   // open device
+   if( (fd = open(szDevName, O_RDWR | O_NOCTTY | O_NDELAY)) == -1 )
+   {
+      CFR_DBG_ERROR( "Error: Can't open device %s\n", szDevName );
+      return -1;
+   }
+   else
+   {
+      CFR_DBG_OUT( "Opened %s\n", szDevName );
+
+      /* Configure terminal attributes */
+      if( tcgetattr(fd, &term_attr) != 0 )
+      {
+         CFR_DBG_ERROR( "Error: tcgetattr() for TERM_DEVICE failed\n" );
+       close ( fd );
+         return -1;
+      }
+     /* setup the serial device communication properties */
+      term_attr.c_cflag = CS8|CREAD|CLOCAL;//|CRTSCTS;
+                                                               /* Control flag
+                                                               CS8     : 8n1 (8bit,no parity,1 stopbit)
+                                                               CREAD   : enable receiving characters
+                                                               CLOCAL  : local connection, no modem control
+                                                               CRTSCTS : output hardware flow control
+                                                               */
+      /* Raw data transmission; No pre- or post-processing */
+      term_attr.c_iflag = 0;                                   // Input flag
+      term_attr.c_oflag = 0;                                   // Output flag
+      term_attr.c_lflag = 0;                                   // Local flag
+
+	  switch(pst_Config->u32_BaudRate)
+	  {
+	  	case 4800:
+			baud = B4800;
+			break;
+	  	case 9600:
+			baud = B9600;
+			break;
+		case 19200:
+			baud = B19200;
+			break;
+		case 57600:
+			baud = B57600;
+			break;
+		case 115200:
+			baud = B115200;
+			break;
+		case 230400:
+			baud = B230400;
+			break;
+		
+		default :
+			baud = B115200;
+			break;
+	  }
+
+      if( cfsetispeed(&term_attr, baud) == -1 )
+      {
+         CFR_DBG_ERROR( "Error: failed to set input baud rate\n" );
+         close (fd);
+       return -1;
+      }
+
+      if( cfsetospeed(&term_attr, baud) == -1 )
+      {
+         CFR_DBG_ERROR( "Error: failed to set output baud rate\n" );
+         close (fd);
+       return -1;
+      }
+
+      if( tcsetattr(fd, TCSAFLUSH, &term_attr) != 0 )
+      {
+         CFR_DBG_ERROR( "Error: tcsetattr() for TERM_DEVICE failed\n" );
+         close (fd);
+       return -1;
+      }
+   }
+
+   return   fd;
+}
+
+
+//todo: rename ST_UART_CONFIG to ST_SERIAL_CONFIG
+int          cfr_usbInitialize( PST_UART_CONFIG pst_Config )
+{
+	char           szDevName[128];
+	int            fd;
+	struct termios term_attr;
+	unsigned int baud = B115200; /* defaults */
+
+   if(pst_Config->psz_ComDevName)
+   {
+      sprintf( szDevName, "/dev/%s", pst_Config->psz_ComDevName );
+      fd = open(szDevName, O_RDWR | O_NOCTTY | O_NDELAY);
+   }
+   else
+   {
+      // generate device name /dev/ttyACM
+      sprintf( szDevName, "/dev/ttyACM%d", pst_Config->u8_Port );
+      // open device
+      fd = open(szDevName, O_RDWR | O_NOCTTY | O_NDELAY);
+
+      if(fd == -1)
+      {
+         // generate device name /dev/ttyUSB
+         sprintf( szDevName, "/dev/ttyUSB%d", pst_Config->u8_Port );
+         // open device
+         fd = open(szDevName, O_RDWR | O_NOCTTY | O_NDELAY);
+      }
+   }
+
+	if(fd == -1)
+	{
+		CFR_DBG_ERROR( "Error: Can't open device /dev/ttyACM%d or /dev/ttyUSB%d\n", pst_Config->u8_Port, pst_Config->u8_Port );
+		return -1;
+	}
+
+	CFR_DBG_OUT( "Opened %s\n", szDevName );
+
+	/* Configure terminal attributes */
+	if( tcgetattr(fd, &term_attr) != 0 )
+	{
+		CFR_DBG_ERROR( "Error: tcgetattr() for TERM_DEVICE failed\n" );
+		close ( fd );
+		return -1;
+	}
+    
+	/* setup the serial device communication properties */
+	term_attr.c_cflag = CS8|CREAD|CLOCAL;//|CRTSCTS;
+                                                               /* Control flag
+                                                               CS8     : 8n1 (8bit,no parity,1 stopbit)
+                                                               CREAD   : enable receiving characters
+                                                               CLOCAL  : local connection, no modem control
+                                                               CRTSCTS : output hardware flow control
+                                                               */
+	/* Raw data transmission; No pre- or post-processing */
+	term_attr.c_iflag = 0;                                   // Input flag
+	term_attr.c_oflag = 0;                                   // Output flag
+	term_attr.c_lflag = 0;                                   // Local flag
+
+	switch(pst_Config->u32_BaudRate)
+	  {
+	  	case 4800:
+			baud = B4800;
+			break;
+	  	case 9600:
+			baud = B9600;
+			break;
+		case 19200:
+			baud = B19200;
+			break;
+		case 57600:
+			baud = B57600;
+			break;
+		case 115200:
+			baud = B115200;
+			break;
+		case 230400:
+			baud = B230400;
+			break;
+		
+		default :
+			baud = B115200;
+			break;
+	  }
+
+	if( cfsetispeed(&term_attr, baud) == -1 )
+	{
+		CFR_DBG_ERROR( "Error: failed to set input baud rate\n" );
+		close (fd);
+		return -1;
+	}
+
+	if( cfsetospeed(&term_attr, baud) == -1 )
+	{
+		CFR_DBG_ERROR( "Error: failed to set output baud rate\n" );
+		close (fd);
+		return -1;
+	}
+
+	if( tcsetattr(fd, TCSAFLUSH, &term_attr) != 0 )
+	{
+		CFR_DBG_ERROR( "Error: tcsetattr() for TERM_DEVICE failed\n" );
+		close (fd);
+		return -1;
+	}
+
+	return   fd;
+}

dectmngr/src/frame/linux/cfr_uart.h

@@ -0,0 +1,44 @@
+/*!
+*  \file       cmbs_uart.h
+*  \brief	   
+*  \author     stein
+*
+*  @(#)  %filespec: cfr_uart.h~DMZD53#2 %
+*
+*******************************************************************************
+*  \par  History
+*  \n==== History ============================================================\n
+*  date        name     version   action                                          \n
+*  ----------------------------------------------------------------------------\n
+*******************************************************************************/
+
+#if   !defined( CFR_UART_H )
+#define  CFR_UART_H
+
+/*! current packet transmission size */
+#define     CFR_BUFFER_WINDOW_SIZE  3
+
+/*! identifier for receive path */
+#define		CFR_BUFFER_UART_REC		0
+/*! identifier for transmit path */
+#define		CFR_BUFFER_UART_TRANS	1
+
+#if defined( __cplusplus )
+extern "C"
+{
+#endif
+void  *      cfr_uartThread( void * pVoid );
+int          cfr_uartInitialize( PST_UART_CONFIG pst_Config );
+int          cfr_usbInitialize( PST_UART_CONFIG pst_Config );
+int			 cfr_uartPacketPartWrite( u8* pu8_Buffer, u16 u16_Size );
+void         cfr_uartPacketWriteFinish( u8 u8_BufferIDX );
+CFR_E_RETVAL cfr_uartPacketPrepare ( u16 u16_size );
+void			 cfr_uartDataTransmitKick ( void );
+
+
+#if defined( __cplusplus )
+}
+#endif
+
+#endif   // CFR_UART_H
+//*/

dectmngr/src/frame/linux/frame.mak

@@ -0,0 +1,29 @@
+FRAMEBASE:=$(PROJDIR)/frame
+
+cfr_objects:=
+####################################################################
+# settle includes
+
+includes += -I$(FRAMEBASE) -I$(FRAMEBASE)/linux 
+
+ifdef CMBS_COMA
+includes += -I$(LIBCOMA)/inc/ -I$(LIBCOMA)/../include
+endif
+
+####################################################################
+# settle objects
+
+cfr_objects += $(OBJDIR)/cfr_uart.o
+cfr_objects += $(OBJDIR)/cfr_cmbs.o
+cfr_objects += $(OBJDIR)/cfr_ie.o
+
+ifdef CMBS_COMA
+cfr_objects += $(OBJDIR)/cfr_coma.o
+endif
+
+####################################################################
+# settle vpath
+
+vpath %.c 	$(FRAMEBASE)
+# linux
+vpath %.c   $(FRAMEBASE)/linux

dectmngr/src/frame/osl/Android.mk

@@ -0,0 +1,32 @@
+LOCAL_PATH:= $(call my-dir)
+
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE := osl
+
+#LOCAL_CFLAGS := \
+
+LOCAL_C_INCLUDES:= \
+	$(LOCAL_PATH)/inc
+
+
+LOCAL_SRC_FILES := \
+	linux/OsLiteCritSect.c \
+	linux/OsLiteEvents.c \
+	linux/OsLiteInit.c \
+	linux/OsLiteIntr.c \
+	linux/OsLiteQueue.c \
+	linux/OsLiteSem.c \
+	linux/OsLiteTask.c \
+	linux/OsLiteTick.c \
+	linux/Smartlog.c \
+	linux/TimeUtils.c
+
+
+#LOCAL_STATIC_LIBRARIES := 
+
+include $(BUILD_STATIC_LIBRARY)
+
+

dectmngr/src/frame/osl/inc/OsLite.h

@@ -0,0 +1,41 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLite.h
+///	@brief		This file exports all OS Lite module functionality. It simply includes all OsLite
+///	@n			.h files. Application should include this file in order to have interfaces of all
+///	@n			OsLite headers.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_H
+#define _OS_LITE_H
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "OsLiteInit.h"
+#include "OsLiteTask.h"
+#include "OsLiteIntr.h"
+#include "OsLiteCritSect.h"
+#include "OsLiteEvents.h"
+#include "OsLiteQueue.h"
+#include "OsLiteSem.h"
+#include "OsLiteTimers.h"
+#include "OsLiteTls.h"
+#include "OsLiteTick.h"
+#include "OsLiteKernel.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // _OS_LITE_H
+

dectmngr/src/frame/osl/inc/OsLiteCritSect.h

@@ -0,0 +1,109 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteCritSect.h
+///	@brief		This file exports the Critical Section kernel object functionality
+/// @n
+///	@n			A critical section is a binary semaphore, which can be taken more than once by the
+///	@n			same task. It can be used in order to get mutual exclusion access to piece of code
+///	@n			by several tasks.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_CRITSECT_H
+#define _OS_LITE_CRITSECT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OsLiteDefs.h"
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// @brief Critical Section handle
+DECLARE_OPAQUE(HCRITICAL_SECTION);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Create a critical section object
+///
+///	@param		None
+/// 
+///	@note		This function shouldn't be called from an ISR context
+///
+///	@return		An handle to a critical section object
+///
+/// @see		OSL_CS_Close
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HCRITICAL_SECTION OSL_CS_Create( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Destroy a critical section object
+///
+///	@param[in]	hCriticalSection	- An handle to a valid critical section object
+/// 
+///	@note		Destroying a critical section which is taken by a task is forbidden
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///
+/// @see		OSL_CS_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_CS_Close( HCRITICAL_SECTION hCriticalSection );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Enter (take) into a critical section
+///
+///	@param[in]	hCriticalSection	- An handle to a valid critical section object
+///	@param[in]	TimeoutMs			- Timeout (in milli seconds) to wait for the critical section,
+///									  OSL_TIMEOUT_INFINITE for infinity
+/// 
+///	@note		A task can enter the same critical section more than once, but it must leave it the
+///				exact amount of times that it entered it.
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		True if the critical section is entered successfully, or False if not and the
+///				timeout expired
+///
+/// @see		OSL_CS_Leave
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_CS_Enter(	HCRITICAL_SECTION	hCriticalSection,
+					uint16				TimeoutMs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Leave (give) a critical section
+///
+///	@param[in]	hCriticalSection	- An handle to a valid critical section object
+/// 
+///	@note		A task is allowed to leave a critical section only if it currently holds it
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///
+/// @see		OSL_CS_Enter
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_CS_Leave(	HCRITICAL_SECTION hCriticalSection );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_CRITSECT_H
+

dectmngr/src/frame/osl/inc/OsLiteDefs.h

@@ -0,0 +1,37 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteDefs.h
+///	@brief		This file exports global definition values for the OS Lite module
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_DEFS_H
+#define _OS_LITE_DEFS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// @brief Define value for infinite timeout waiting
+#define OSL_TIMEOUT_INFINITE		0xffff
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_DEFS_H

dectmngr/src/frame/osl/inc/OsLiteEvents.h

@@ -0,0 +1,150 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteEvents.h
+///	@brief		This file exports the Event kernel object functionality
+/// @n
+///	@n			Events are synchronization objects, allowing few tasks to be blocked until a
+///	@n			specific event is happening. The waiter tasks are slipping on the event, and the
+///	@n			producer task is signaling it in order to notify the waiters.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_EVENTS_H
+#define _OS_LITE_EVENTS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OsLiteDefs.h"
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///	@brief	Event handle type
+DECLARE_OPAQUE(HEVENT);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Create an event object
+///
+///	@param		None
+/// 
+///	@note		This function shouldn't be called from an ISR context
+///
+///	@return		An handle to the created event object
+///
+/// @see		OSL_EVENT_Close
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HEVENT OSL_EVENT_Create( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Destroy an event object
+///
+///	@param[in]	hEvent		- Handle to a valid event object for destroying
+/// 
+///	@note		Destroyig of event on which a task is waiting is forbidden
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///
+/// @see		OSL_EVENT_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_EVENT_Close( HEVENT hEvent );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Set (Signal) an event
+///
+///	@param[in]	hEvent		- Handle to a valid event object
+/// 
+///	@note		When calling this function, all tasks which are currently waiting for the event
+///				(using OSL_EVENT_Wait) will be waken up. The state of the event after this call is
+///				dependent on the parameters sent by the waiters tasks to the OSL_EVENT_Wait function:
+///				If one of these tasks set Clear = True, then the event will be cleared, otherwise
+///				it will remain signaled until reset by OSL_EVENT_Reset or OSL_EVENT_Wait.
+///
+///	@return		None
+///
+/// @see		OSL_EVENT_Reset
+/// @see		OSL_EVENT_Test
+/// @see		OSL_EVENT_Wait
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_EVENT_Set  ( HEVENT hEvent );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Reset (Clear) an event
+///
+///	@param[in]	hEvent		- Handle to a valid event object
+/// 
+///	@note		This function clears the state of the event. Other way to clear the state of the
+///				event is using the Clear parameter for the OSL_EVENT_Wait function.
+///
+///	@return		None
+///
+/// @see		OSL_EVENT_Set
+/// @see		OSL_EVENT_Test
+/// @see		OSL_EVENT_Wait
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_EVENT_Reset( HEVENT hEvent );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Get the state of an event
+///
+///	@param[in]	hEvent		- Handle to a valid event object
+/// 
+///	@note		This function retrieves the current state of the event
+///
+///	@return		True if the event is currently signaled, or False if it is cleared
+///
+/// @see		OSL_EVENT_Set
+/// @see		OSL_EVENT_Reset
+/// @see		OSL_EVENT_Wait
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_EVENT_Test  ( HEVENT hEvent );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Wait for an event to be signaled
+///
+///	@param[in]	hEvent		- Handle to a valid event object
+///	@param[in]	Clear		- Should the event be cleared (reset) right after it is being signaled?
+///	@param[in]	TimeoutMs	- Timeout to wait for the event, OSL_TIMEOUT_INFINITE for infinity
+/// 
+///	@note		This function allows a task to be blocked until an event object is being signaled,
+///				or a timeout is expired. In case the event was signaled before the timeout is
+///				expired, the event will be cleared (reset) if we passed True in the Clear parameter
+///				to this function.
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		True if the event is signaled, or False if the timeout expired before the event was
+///				signaled
+///
+/// @see		OSL_EVENT_Set
+/// @see		OSL_EVENT_Reset
+/// @see		OSL_EVENT_Test
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_EVENT_Wait(	HEVENT	hEvent ,
+						bool	Clear,
+						uint16	TimeoutMs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_EVENTS_H
+

dectmngr/src/frame/osl/inc/OsLiteInit.h

@@ -0,0 +1,113 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteInit.h
+///	@brief		This file exports the RTOS initialization functions
+/// @n
+///	@n			The application should call OSL_Init() in order to inialize RTOS memory.
+///	@n			OSL_Start() should be called in order to start the scheduler.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_INIT_H
+#define _OS_LITE_INIT_H
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+//
+// @brief		Callback function prototype, called by Idle for Stop mode
+//
+typedef void (*IdleHookProc)( void );
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Initialize the RTOS
+///
+///	@param		None
+///
+///	@note		This function should be called from the main() function, before calling OSL_Start
+///
+///	@return		None
+///
+/// @see		OSL_Start
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_Init( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Start running the RTOS scheduler
+///
+///	@param		None
+///
+///	@note		This function should be called from the main() function, after calling OSL_Init
+/// @n			The user must create at least one task (using OSL_TASK_Create function), before
+///				calling this function
+///
+///	@return		This function won't return (it will start running the highest priority task)
+///
+/// @see		OSL_Start
+/// @see		OSL_TASK_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_Start( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Notify the RTOS that the main task has started to run
+///
+///	@param		None
+///
+///	@note		This function should be called only once, from a context of a task, and after the
+/// @n			the RTOS tick timer was configured.
+/// @n			Usually, the application will call it from the context of it's main task, but it
+/// @n			can be called also from any other task as well.
+/// @n			Please noe that it should be called as soon as possible after the ROTS has started
+/// @n			running tasks.
+/// @n			NOTE: it should be called only once, from a selected task which starts running on
+/// @n			application startup (and not from every task).
+///
+///	@return		None
+///
+/// @see		OSL_Start
+/// @see		OSL_Init
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_NotifyMainTaskStart( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Register a function which will be called by the Idle task
+///
+///	@param		Func - the callback function to be called by Idle task
+///
+///	@note		Usual use of this function is in order to implement stop-mode or
+///				some idle time statistics
+///
+///	@return		None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_RegisterIdleHook( IdleHookProc Func );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_INIT_H
+

dectmngr/src/frame/osl/inc/OsLiteIntr.h

@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteIntr.h
+///	@brief		This file exports ISR registration, and interrupts disabling funtionality
+/// @n
+///	@n			ISR registration is used in order to register functions as ISR callbacks.
+/// @n			Disabling and restoring of interrupts is used in order to prevent ISRs and context
+/// @n			switches for a short time periods.
+/// @n			Application should be very careful will ISR disabling, in order not to hurt the
+/// @n			responsiveness of the whole system. 
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_INTR_H
+#define _OS_LITE_INTR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OsLiteDefs.h"
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// @brief Cookie for restoring interrupts
+DECLARE_OPAQUE(IntrCookie);
+
+/// @brief ISR callback function prototype
+typedef void (*OSL_IsrFunc)(void);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Disable interrupts
+///
+///	@param		None
+/// 
+///	@note		This function should be used with a great care. Disabling the intterupts should be
+///				done only for a very short periods of time. Otherwise, the system responsiveness
+///				will be hurt, and we might also lose interrupts and cause a crash of the system.
+///
+///	@return		A 'cookie' that can be saved in order for restoring the intterupts to the state
+///				before calling this function
+///
+/// @see		OSL_INTR_RestoreInterrupts
+///////////////////////////////////////////////////////////////////////////////////////////////////
+IntrCookie OSL_INTR_DisableInterrupts( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Restores the interrupts back to the previous state (enabled or disabled)
+///
+///	@param[in]	Cookie		- Previous interrupt state. The return value for the last call to
+///							  OSL_INTR_DisableInterrupts
+/// 
+///	@return		None
+///
+/// @see		OSL_INTR_DisableInterrupts
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_INTR_RestoreInterrupts( IntrCookie Cookie );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Register an ISR (Interrupt Service Routine)
+///
+///	@param[in]	Int		- ISR type (=bit number in the ICU status register of the chip)
+///	@param[in]	Isr		- Callback function to be called once the intterupt is enabled and active
+/// 
+///	@note		In case there is already a function registered for the same interrupt, it will be
+///				just override by the function given to this function
+///	@n			ISR functions should be short as possible
+///
+///	@return		None
+///
+/// @see		OSL_IsrFunc
+/// @see		OSL_INTR_GetRegisteredIsr
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_INTR_RegisterIsr( uint16 Int, OSL_IsrFunc Isr );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Get the current registered ISR (Interrupt Service Routine)
+///
+///	@param[in]	Int		- ISR type (=bit number in the ICU status register of the chip)
+/// 
+///	@return		The currently registered ISR for the specified interrupt
+///
+/// @see		OSL_IsrFunc
+/// @see		OSL_INTR_RegisterIsr
+///////////////////////////////////////////////////////////////////////////////////////////////////
+OSL_IsrFunc OSL_INTR_GetRegisteredIsr( uint16 Int );
+	
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Test whether we are currently running in an ISR context
+///
+///	@param		None
+/// 
+///	@note		This function can be used in case we have different behavior dependent on the
+///				context in which we are currently running
+///
+///	@return		True if we are at ISR context, and False if we are at RTOS task context
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_INTR_IsIsrContext( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_INTR_H
+

dectmngr/src/frame/osl/inc/OsLiteKernel.h

@@ -0,0 +1,60 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteKernel.h
+///	@brief		This file exports the kernel object functionality
+/// @n
+///
+///	@internal
+///	@author		Alex Krayz
+///	@date		14/07/2008
+///	@version	version 1.0
+///
+///	Copyright (C) 2008 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_KERNEL_H
+#define _OS_LITE_KERNEL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Returns the number of ms until next event which  
+/// @n			must wake-up the system
+///
+/// @note
+///
+///	@return		the time in ms for which the system can go to sleep
+///////////////////////////////////////////////////////////////////////////////////////////////////
+uint32 OSL_KERNEL_GetMaximalSleepTime(    void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Advance internal data structure of RTOS  
+/// @n			by specified number of ms.
+///
+///	@param[in]	SleepTime - number of ms for advancing
+///
+/// @note
+///
+///	@return		None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_KERNEL_WakeupFromSleep(    uint32 SleepTime );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_KERNEL_H
+

dectmngr/src/frame/osl/inc/OsLiteNetwork.h

@@ -0,0 +1,84 @@
+#ifndef __NETWORK__
+#define __NETWORK__
+
+
+#ifndef WIN32
+#include <netinet/in.h>
+#else
+#include <Winsock2.h>
+#endif
+
+typedef void * SELECT_HANDLE;
+typedef void * CONNECT_HANDLE; 
+
+
+int InitNetwork(void);
+void ReleaseNetwork(void);
+int SocketError(void);
+
+typedef enum
+{
+    SOCK_TYPE_TCP,
+    SOCK_TYPE_UDP
+} SOCKET_TYPE; 
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+//
+//  Socket
+//
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+int SockCreate(SOCKET_TYPE eType);
+void SocketClose(int sock);
+CONNECT_HANDLE SocketConnectCreate(const char *IP, unsigned short u16_Port);
+void SocketConnectRelease(CONNECT_HANDLE pst_Handle);
+
+int IpAddressByHostName(IN const char *sHostName, OUT char *sIP);
+
+typedef void (*pfnConnectCB)(int res);
+typedef int (*pfnStop)(void);
+
+// Asynchronous connect with timeout (-1 infinite)
+// create separate thread
+// calls pfn_ConnectCB when connected
+// check pfn_StopCB if should stop 
+int SockConnectAsync(int sock, const char* sHost, unsigned short u16_Port,pfnConnectCB pfn_ConnectCB, pfnStop pfn_StopCB, unsigned int u32_Timeout);
+
+int SockConnect(int sock, CONNECT_HANDLE pst_Handle);
+int SockBind(int sock, CONNECT_HANDLE pst_Handle);
+int SockBindAnyIP(int sock, unsigned intport);
+int SocketSend(int sock, const unsigned char*pu8Buffer, unsigned intsize);
+int SocketSendTo(int sock, const unsigned char*pu8_Buffer, unsigned intsize, CONNECT_HANDLE pst_Handle);
+int SocketSetRxBuffer(int sock, unsigned intSize); 
+int SocketSetTxBuffer(int sock, unsigned intSize); 
+
+// if > 0,  Bytes received
+// if == 0, Connection closed
+// if < 0,  recv failed with error
+int SocketRecv(int sock, unsigned char *pu8Buffer, unsigned int size,SOCKET_TYPE eType,struct sockaddr *cliaddres);
+
+/////////////////////////////////////////
+//// Select
+/////////////////////////////////////////
+
+// create select handle
+SELECT_HANDLE SocketSelectCreate(void);
+
+// set FDs
+void SocketSelectSet(SELECT_HANDLE hHandle, const int *pReadFDs, unsigned int u32_ReadFDsSize, const int *pWriteFDs, unsigned int u32_WriteFDsSize);
+
+// release select handle
+// all FDs should be stopped
+void SocketSelectRelease(SELECT_HANDLE handle);
+
+// Select for requested sockets
+// pu32_Entries with FD_SETSIZE size
+// timeout im ms
+// return the number of selected
+int SocketSelect(SELECT_HANDLE handle, unsigned int*pu32_ReadEntries, unsigned int*pu32_ReadSize, unsigned int*pu32_WriteEntries, unsigned int*pu32_WriteSize, unsigned int u32_Timeout);
+
+// set timeout for socket recieve (0 for infinite)
+int SetSocketRecvTimeout(int sock, unsigned int u32_TimeoutSec);
+
+#endif // __NETWORK__

dectmngr/src/frame/osl/inc/OsLiteQueue.h

@@ -0,0 +1,123 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteQueue.h
+///	@brief		This file exports the Queue kernel object functionality
+/// @n
+///	@n			This module allows handling of simple queue objects, which can only hold (void*)
+///	@n			data items. The queue is handling the items in a FIFO (First In First Out) algorithm.
+///	@n			Supported operations:
+///	@n				Create a queue
+///	@n				Destroy a queue
+///	@n				Send an item to a queue
+///	@n				Receive an item from a queue
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_QUEUE_H
+#define _OS_LITE_QUEUE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OsLiteDefs.h"
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///	@brief	Queue handle type
+DECLARE_OPAQUE(HQUEUE);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Create a queue object
+///
+///	@param[in]	pMem		- Memory for the queue data
+///	@param[in]	NumMsgs		- Number of messages in the queue. Message type is always (void*)
+/// 
+///	@note		This function shouldn't be called from an ISR context
+///
+///	@return		An handle to the created queue object
+///
+/// @see		OSL_Q_Close
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HQUEUE OSL_Q_Create(	void*	pMem,
+						uint16	NumMsgs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Destroy queue object
+///
+///	@param[in]	hQueue		- Handle to a valid queue object for destroying.
+/// 
+/// @note		Destroying of a queue on which a task is waiting (for send or receive) is forbidden
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///
+/// @see		OSL_Q_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_Q_Close( HQUEUE	hQueue );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Put an item in a queue
+///
+///	@param[in]	hQueue		- Handle to a valid queue object for destroying
+///	@param[in]	pData		- Item to be pushed into the queue
+///	@param[in]	TimeoutMs	- Timeout (in milli seconds) to wait for an empty slot in the queue.
+///							  OSL_TIMEOUT_INFINITE for infinity
+///
+///	@note		The function waits until there is free space in the queue (or the timeout expires)
+///				and then put the item in the queue
+///	@n			This function shouldn't be called from an ISR context when TimeoutMs != 0.
+/// @n			If TimeoutMs == 0, this function can be called from an ISR context.
+///
+///	@return		True if the operation succeeded. False if timeout expired (the queue is full)
+///
+/// @see		OSL_Q_Receive
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_Q_Send(	HQUEUE	hQueue,
+					void*	pData,
+					uint16	TimeoutMs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Read an item from a queue
+///
+///	@param[in]	hQueue		- Handle to a valid queue object for destroying
+///	@param[out]	ppData		- Pointer to Item address. *ppData will contain the retrieved value
+/// @param[in]	TimeoutMs	- Timeout (in milli seconds) to wait until there is any item in the
+///							  queue. OSL_TIMEOUT_INFINITE for infinity
+///
+///	@note		The function waits until there is an item in the queue (or the timeout expires)
+///				and then read it
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		True if the operation succeeded. False if timeout expired (the queue is empty)
+///
+/// @see		OSL_Q_Send
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_Q_Receive(		HQUEUE	hQueue,
+						void**	ppData,
+						uint16	TimeoutMs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_QUEUE_H
+

dectmngr/src/frame/osl/inc/OsLiteSem.h

@@ -0,0 +1,109 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteSem.h
+///	@brief		This file exports the Semaphore kernel object functionality
+/// @n
+///	@n			This module gives semaphores functionality. Semaphores are synchronization objects,
+///	@n			letting the application the ability to share resources between several tasks.
+///	@n			Semaphore behavior:
+///	@n			The semaphore can have a value of 0 or more.
+///	@n			'Give' increases the semaphore value by 1, 'Take' decreases it by 1.
+///	@n			When the value is 0, the semaphore cannot be 'Taken'.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_SEM_H
+#define _OS_LITE_SEM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OsLiteDefs.h"
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///	@brief		Semaphore handle type
+DECLARE_OPAQUE(HSEMAPHORE);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Create a semaphore object
+///
+///	@param[in]	InitialValue	- Initial value of the semaphore. Can be 1 or more
+///
+///	@note		This function shouldn't be called from an ISR context
+///
+///	@return		An handle to a semaphore object
+///
+/// @see		OSL_SEM_Close
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HSEMAPHORE OSL_SEM_Create( uint16 InitialValue );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Destroy a semaphore object
+///
+///	@param[in]	hSemaphore	- Handle to a valid semaphore object
+///
+///	@note		No task should be pending for the deleted semaphore object
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///
+/// @see		OSL_SEM_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_SEM_Close( HSEMAPHORE hSemaphore );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Give the semaphore. Should be called once the application finished using the
+///				resource which is being guarded by the semaphore.
+///
+///	@param[in]	hSemaphore	- Handle to a valid semaphore object
+///
+///	@return		None
+///
+/// @see		OSL_SEM_Take
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_SEM_Give( HSEMAPHORE hSemaphore );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Take the semaphore. Should be called before the application start accesing the
+///				resource which is being guarded by the semaphore.
+///
+///	@param[in]	hSemaphore	- Handle to a valid semaphore object
+///	@param[in]	TimeoutMs	- Timeout to wait for the semaphore. Value of OSL_TIMEOUT_INFINITE for
+///							  infinity
+///
+///	@note		This function shouldn't be called from an ISR context when TimeoutMs != 0.
+/// @n			If TimeoutMs == 0, this function can be called from an ISR context.
+///
+///	@return		True if the semaphore was available (not 0). False in case of a timeout
+///
+/// @see		OSL_SEM_Give
+///////////////////////////////////////////////////////////////////////////////////////////////////
+bool OSL_SEM_Take(	HSEMAPHORE	hSemaphore,
+					uint16		TimeoutMs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_SEM_H
+

dectmngr/src/frame/osl/inc/OsLiteTask.h

@@ -0,0 +1,163 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteTask.h
+///	@brief		This file exports the Task kernel object functionality
+/// @n
+///	@n			This interface allows:
+///	@n				Creation and destroying of tasks
+///	@n				Sleep functionality
+///	@n				Disaling and enabling of preemption (task switching) mechanism
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_TASKS_H
+#define _OS_LITE_TASKS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "TypeDefs.h"
+#include "OsLiteDefs.h"
+
+#ifndef UNUSED_PARAMETER
+#define UNUSED_PARAMETER(x) (void)(x)
+#endif
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///	@brief	Callback function, which the task starts from
+typedef void (*TaskProc)( void* ProcParam );
+
+///	@brief	Callback function for retreiving stacks usage
+typedef void (*StackUsageProc)( uint16 Priority, uint8 Percentages );
+	
+///	@brief	Task handle type
+DECLARE_OPAQUE(HTASK);
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///	@brief	Application tasks possible priorities range. 0 is highest priority. Lowest priority
+/// @n		is set according to number of tasks declares in OsLiteConfig.h. Please note that
+/// @n		if timers are in use, a dedicated task for the timers will be created (which is not
+/// @n		being count inside OSL_MAX_TASKS definition)
+#define OSL_TASK_PRIORITY_HIGHEST		0
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Create and start a task
+///
+///	@param[in]	Proc		- Entry point procedure of the created task
+///	@param[in]	ProcParam	- Parameter for the entry point procedure
+///	@param[in]	Priority	- Task priority (two tasks can't have the same priority).
+///							  Priority must be in range of OSL_TASK_PRIORITY_HIGHEST to
+///							  OSL_TASK_PRIORITY_LOWEST (lower number is higher priority).
+///	@param[in]	pStack		- Pointer to the task's stack - cannot be NULL
+///	@param[in]	StackSize	- The size of the stack in bytes. Must be greater than 0
+/// 
+///	@note		Created task runs immediately (according to their priority)
+/// @n			Task must call OSL_TASK_Kill( OSL_TASK_GetCurrentTask() ) before it exists
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		An handle to a task object. The handle is NULL in case there is already existing
+///				task at the same priority. In any other case of error, the function will enter
+///				ASSERT internally (so it won't return).
+///
+/// @see		OSL_TASK_Kill
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HTASK OSL_TASK_Create(	TaskProc			Proc,
+						void*				ProcParam,
+						uint16				Priority,
+						void*				pStack,
+						uint16				StackSize );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Kill a task
+///
+///	@param[in]	hTask	- handle to the task object which should be killed
+/// 
+///	@note		Each task must call OSL_TASK_Kill( OSL_TASK_GetCurrentTask() ) before it exists
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///
+/// @see		OSL_TASK_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TASK_Kill( HTASK hTask );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Suspend the current task to a given amount of milli seconds
+///
+///	@param[in]	TimeoutMs	- Number of milli seconds for which we want current task to be suspended
+/// 
+/// @note		Passing TimeoutMs = 0 will do nothing (no context switch will happen, since there
+///				is only	one task per priority)
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TASK_Sleep( uint16 TimeoutMs );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Get handle for current task
+///
+///	@param		None
+/// 
+///	@note		This function shouldn't be called from an ISR context
+///
+///	@return		Handle to current task object
+///
+/// @see		OSL_TASK_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HTASK OSL_TASK_GetCurrentTask( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Get stack usage (percentages) for all active tasks
+///
+///	@param[in]	StackUsageCb - callback function which is called for each active task
+///
+/// @note		When this function is running, it is looping over all active tasks, compute it's
+/// @n			stack's usage, and call the given callback. So, the caller's callback will be
+/// @n			called during the runtime of this function.
+///
+///	@return		None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TASK_GetStacksUsage(    StackUsageProc StackUsageCb );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Set task property which decides whether a timed-delay 
+/// @n		    ( sleep, wait on semaphore/queue/event with timeout )
+/// @n 			should wake-up the system in case of timeout.
+///
+///	@param[in]	hTask	- handle to the task object which should be set.
+///	@param[in]	WakeUp  - 1 means wakeup, 0 means freeze 
+///
+/// @note		
+///
+///	@return		None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TASK_SetWakeupPolicy( HTASK hTask, uint8 WakeUp );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_TASKS_H
+

dectmngr/src/frame/osl/inc/OsLiteTick.h

@@ -0,0 +1,82 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteTick.h
+///	@brief		This file exports the Timer tick configuration, which is needed by the RTOS
+/// @n
+///	@n			This interface supplis all needed information in order to configure timer interrupt
+///	@n			for the RTOS.
+///	@n			Every RTOS needs tick function in order to support timed wait and timer kernel
+///	@n			objects functionality.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_TICK_H
+#define _OS_LITE_TICK_H
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include "OsLiteIntr.h"
+#include "TypeDefs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Get the number of ticks in a second, which should be configured for the RTOS tick
+///				handler interrupt
+///
+///	@param		None
+///
+/// @note		Tick handler is used by an RTOS in order to implement timed-wait (waiting for
+///				semaphore, sleep, etc.) and timers functionality
+///
+///	@return		The required RTOS's tick handler frequency
+///
+/// @see		OSL_TICK_GetTickFunc
+///////////////////////////////////////////////////////////////////////////////////////////////////
+uint16 OSL_TICK_GetNumTicksInSec( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Get the RTOS tick handler function
+///
+///	@param		None
+///
+/// @note		The returned function will be called every timer tick (according to frequency got
+///				by the call to OSL_TICK_GetNumTicksInSec)
+///
+///	@return		RTOS timer tick handler function
+///
+/// @see		OSL_TICK_GetNumTicksInSec
+///////////////////////////////////////////////////////////////////////////////////////////////////
+OSL_IsrFunc OSL_TICK_GetTickFunc( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+uint32  OSL_Jiffies(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // _OS_LITE_TICK_H
+

dectmngr/src/frame/osl/inc/OsLiteTimers.h

@@ -0,0 +1,128 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteTimers.h
+///	@brief		This file exports the Timer kernel object functionality
+/// @n
+/// @n			This file allows creating and destroying timer objects. Timer object can generate
+///	@n			one time, or periodic callback calls. The timer callbacks are being called from a
+///	@n			dedicated task's context.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_TIMERS_H
+#define _OS_LITE_TIMERS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OsLiteDefs.h"
+#include "TypeDefs.h"
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///	@brief		Timer handle type
+DECLARE_OPAQUE(HTIMER);
+
+///	@brief		Callback function prototype, called by the timer
+typedef void (*TimerProc)(	HTIMER	hTimer,
+							void*	ProcParam );
+
+#define OSL_TIMER_PERIODIC						   (1 << 1)
+#define OSL_TIMER_ABSOLUTE						   (1 << 2)
+#define OSL_TIMER_DONT_ACTIVATE_ON_TIME_SHIFT      (1 << 3)
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Create and start a timer
+///
+///	@param[in]	TimeoutMs	- Timeout for executing the callback. Must be greater than 0
+///	@param[in]	Flags		- Mask of flags (periodic / absolute)
+///	@param[in]	Proc		- Callback to be called when timer expires
+///	@param[in]	ProcParam	- Parameter for the executed callback
+/// 
+///	@note		You must kill a timer, even if the timer is non-periodic, and was expired
+///	@n			This function shouldn't be called from an ISR context
+///
+///	@return		An handle to a timer object
+///
+/// @see		TimerProc
+/// @see		OSL_TIMER_Kill
+///////////////////////////////////////////////////////////////////////////////////////////////////
+HTIMER OSL_TIMER_Create(	uint32		TimeoutMs,
+							uint32		Flags,
+							TimerProc	Proc,
+							void*		ProcParam );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Stop and destroy a timer
+///
+///	@param[in]	hTimer	- handle to an existing timer object
+/// 
+///	@note		A timer must be killed after finishing using it. If the timer is periodic, calling
+/// @n			this function will stop and destroy it. If the timer is non-periodic, calling this
+/// @n			function will cancel and destroy the timer if it wasn't expired, and will only
+/// @n			destroy it if it was already expired.
+///	@n			This function shouldn't be called from an ISR context
+/// @n			You are allowed to call this function from the callback of the timer
+///
+///	@return		None
+///
+/// @see		OSL_TIMER_Create
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TIMER_Kill(	HTIMER hTimer );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Set timer property which will define whether 
+/// @n			this timer should wake-up the system or not.
+///
+///	@param[in]	hTimer	- handle to timer object	
+///	@param[in]	WakeUp  - 1 means wakeup, 0 means freeze 
+///
+///	@return		None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TIMER_SetWakeupPolicy( HTIMER hTimer, uint8 WakeUp );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// @brief		Initializes timers module
+/// 
+/// @return 	None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TIMER_Init( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// @brief 		Definitalizes timers module, resets SIGALRM and destroys list mutex
+/// @return 	None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TIMER_Release();
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+/// @brief		Informs Timers that system time was changed
+///	@param[in]	TimeShiftInMs  - Time change in ms (can be negative)
+/// @return 	None
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TIMER_SystemTimeChanged(int32 TimeShiftInMs);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_TIMERS_H
+

dectmngr/src/frame/osl/inc/OsLiteTls.h

@@ -0,0 +1,64 @@
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///
+///	@file		OsLiteTls.h
+///	@brief		Thread Local Storage interface 
+///
+///				This module allows storing and retreiving one void* variable
+///				for each task.
+///
+///	@internal
+///	@author		Shlomi Mor
+///	@date		26/12/2006
+///	@version	version 1.0
+///
+///	Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _OS_LITE_TLS_H
+#define _OS_LITE_TLS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Returns the stored TLS value for the current task
+///
+///	@param		None
+/// 
+///	@note		This function shouldn't be called from an ISR context.
+///
+///	@return		(void*) value stored for current task
+///
+/// @see		OSL_TLS_SetValue
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void* OSL_TLS_GetValue( void );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///	@brief		Store TLS value for the current task
+///
+///	@param[in]	Value	value to be stored
+/// 
+///	@note		This function shouldn't be called from an ISR context.
+///
+/// @return		None
+///
+/// @see		OSL_TLS_GetValue
+///////////////////////////////////////////////////////////////////////////////////////////////////
+void OSL_TLS_SetValue( void* Value );
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // _OS_LITE_TLS_H
+

dectmngr/src/frame/osl/inc/TypeDefs.h

@@ -0,0 +1,370 @@
+ ////////////////////////////////////////////////////////////////////////////////////////////////////
+///	
+///	@file		Typedefs.h	
+///	@brief		Defining types and macros according to specific compiler
+///	
+///	@internal
+///	@author		Shlomi Mor
+///	@date		01/10/2006
+///	@version	version 0.1
+///
+///		Copyright (C) 2006 DSP GROUP, INC .   All Rights Reserved
+///
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _TYPEDEFS_H
+#define _TYPEDEFS_H
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#include <limits.h>
+
+///////////////////////////////////////////////////////////////////////////////
+// DEBUG
+///////////////////////////////////////////////////////////////////////////////
+
+///
+/// @brief endianess definitions
+///
+#define HOST_BIG_ENDIAN		0
+#define HOST_LITTLE_ENDIAN	1
+#define HOST_ENDIAN			HOST_LITTLE_ENDIAN
+
+///
+/// @brief MIN, MAX and RANGE macros
+///
+#ifndef MIN
+#define MIN(a, b)	( (a) < (b) ? (a) : (b) )
+#endif // MIN
+
+#ifndef MAX
+#define MAX(a, b)	( (a) > (b) ? (a) : (b) )
+#endif // MAX
+
+#ifndef RANGE
+#define RANGE(min, x, max)	( (((min) > (x)) || ((x) > (max))) ? false : true )
+#endif // RANGE
+
+///
+/// @brief IN, OUT and INOUT macros
+///
+#ifndef IN
+	#define IN
+#endif // IN
+
+#ifndef OUT
+	#define OUT
+#endif // OUT
+
+#ifndef INOUT
+	#define INOUT
+#endif // INOUT
+
+
+#define NORETURN
+
+#define RAM_FUNC
+#define FAST_FUNC
+#define VERY_FAST_FUNC
+#define END_FUNC
+
+
+
+
+///
+/// @brief Obsolete PACKED macro. Use PACKED_STRUCT instead (see below)
+///
+#ifndef PACKED
+	#define PACKED "Error: Use PACKED_STRUCT instead!!!"
+#endif // PACKED
+
+///
+///	@brief	Macro to be used when decalring "packed" struct
+///
+///	Use this macro when you want to declare a "packed" struct. Usage:
+///		typedef PACKED_STRUCT	_MyPackedStruct 
+///		{
+///			uint32 FourBytes;
+///			uint16 Twobytes;
+///			uint8  Onebyte;
+///		} RESTORE_PACK(MyPackedStruct);
+///
+///	@note	Windows is not supported. If you want to use a "packed" struct
+/// 		in a code that should be compiled for WIN32, take care of it 
+///			in the code. Example:
+///	
+///		#ifdef WIN32
+///			#pragma pack(1)
+///		#endif
+///		typedef PACKED_STRUCT	_MyPackedStruct 
+///		{
+///			uint32 FourBytes;
+///			uint16 Twobytes;
+///			uint8  Onebyte;
+///		} RESTORE_PACK(MyPackedStruct);
+///		#ifdef WIN32
+///			#pragma pack()
+///		#endif
+/// 
+#ifndef PACKED_STRUCT
+	#if defined(WIN32)
+		#define PACKED_STRUCT struct
+	#elif defined(__GNUC__)
+		#define PACKED_STRUCT struct __attribute__((packed))
+	#elif defined(__CC_ARM)	// ARM_ADS
+		#define PACKED_STRUCT __packed struct
+	#elif defined(__ICCARM__) // ARM_IAR
+		#define PACKED_STRUCT _Pragma("pack(push,1)") struct
+	#endif
+#endif // PACKED_STRUCT
+
+///
+///	@brief	PACKED_UNION macro. To be used when decalring "packed" union (same as for packed struct)
+///
+#ifndef PACKED_UNION
+	#if defined(WIN32)
+		#define PACKED_UNION union
+	#elif defined(__GNUC__)
+		#define PACKED_UNION union __attribute__((packed))
+	#elif defined(__CC_ARM)	// ARM_ADS
+		#define PACKED_UNION __packed union
+	#elif defined(__ICCARM__) // ARM_IAR
+		#define PACKED_UNION _Pragma("pack(push,1)") union
+	#endif
+#endif // PACKED_STRUCT
+
+#ifndef RESTORE_PACK
+	#if defined(WIN32)
+		#define RESTORE_PACK(Name) Name
+	#elif defined(__GNUC__)
+		#define RESTORE_PACK(Name) Name
+	#elif defined(__CC_ARM)	// ARM_ADS
+		#define RESTORE_PACK(Name) Name
+	#elif defined(__ICCARM__) // ARM_IAR
+		#define RESTORE_PACK(Name) _Pragma("pack(pop)") Name
+	#endif
+#endif
+
+///
+///	@brief	DRAG_INTO_LINKAGE macro. To be used in order to force the linker inserting a symbol
+/// @n		into the executable. Usually used for ISR functions (Interrupt Service Routine)
+///
+#define DRAG_INTO_LINKAGE(Symbol)					\
+{													\
+	volatile int DragIntoLinkage = (int)(Symbol);	\
+	(void)DragIntoLinkage;							\
+}
+
+
+
+///
+///	@brief		Size in bytes
+///
+#define SIZEOF_B(x)		( sizeof(x) )
+
+///
+///	@brief		Size in chars
+///
+#define SIZEOF_C(x)		( sizeof(x) )
+
+///
+///	@brief		Size in words
+///
+#define SIZEOF_W(x)		( SIZEOF_C(x) / SIZEOF_C(uint16) )
+
+///
+///	@brief	ARGUSED macro. Use in order to prevent compiler warning because of unused function parameter.
+///
+#define ARGUSED(x) (void)(x)
+
+///
+///	@brief	LENGTHOF macro. Use in order to get number of items in array.
+///
+#define LENGTHOF(x) (sizeof(x) / sizeof((x)[0]))
+
+///
+///	@brief	SIZE_IN_BYTES macro. Use in order to get the size of a variable/type in bytes.
+///
+#define SIZE_IN_BYTES(x) (sizeof(x)*CHAR_BIT/8)
+
+///
+///	@brief	ROUND_UP macros
+///
+#define ROUND_UP(x,n) 			( ( (uint32)(x) + (uint32)(n) - 1 ) & ( ~((n)-1)) )
+#define ROUND_UP_TO_TYPE(x,n)	( ( (uint32)(x) + SIZE_IN_BYTES(n) - 1) & ~(SIZE_IN_BYTES(n)-1) )
+
+///
+///	@brief	ROUND_DOWN macros
+///
+#define ROUND_DOWN(x,n) 		( (uint32)(x) & ~((n)-1) )
+#define ROUND_DOWN_TO_TYPE(x,n)	( (uint32)(x)  & ~(SIZE_IN_BYTES(n)-1) )
+
+///
+///	@brief	FIELD_MASK macro. Use in order to create a mask of bits in which bits Low..High are set.
+///
+#define FIELD_MASK( Low, High ) ( ((1 << ((High)-(Low)+1)) - 1) << (Low) )
+
+///
+///	@brief	OFFSET_OF macro. Use in order to get the offset of a field in a struct. Should not be
+/// @n		used on packed structs.
+///
+#define OFFSET_OF( StructName, FieldName ) \
+	((int)(&(((StructName*)0)->FieldName)))
+
+///
+///	@brief	UPWARD_CAST macro. Use in order to implement C++ using C.
+///
+#define UPWARD_CAST( BaseClassName, DerivedClassName, BaseClassMemberName, BaseClassPtr ) \
+	((DerivedClassName*)(((int)BaseClassPtr) - OFFSET_OF( DerivedClassName, BaseClassMemberName )))	
+
+///
+///	@brief	Kb macro. Use to specify 1024 multiplier.
+///
+#define Kb	*1024
+
+///
+/// @brief	Integer types. Portable code MUST use the types below, and not the compiler internal types,
+/// @n		since they might have different sizes when using different compilers/processors.
+///
+//#ifdef __LINUX__
+
+#ifndef _TYPEDEFS_NORMAL
+#define _TYPEDEFS_NORMAL
+typedef signed char			int8;
+typedef signed short			int16;
+typedef signed long			int32;
+#endif
+
+typedef unsigned char			uint8;
+typedef unsigned short			uint16;
+typedef unsigned long			uint32;
+typedef unsigned long long		uint64;
+
+# ifndef __BIONIC__
+typedef unsigned int			uint;
+#endif // __BIONIC__
+								
+typedef signed char				sint8;
+typedef signed short			sint16;
+typedef signed long				sint32;
+typedef signed long long		sint64;
+typedef signed int				sint;
+
+typedef signed long long		int64;
+
+//typedef uint16 					bool_type;
+
+
+#if 0
+/// Define a 128 bit type
+#if defined(__cplusplus)
+
+PACKED_STRUCT uint128
+{ 
+	// IAR comiler supplies the default behaviour like this (binary operations).
+
+	bool operator==(const uint128& other) const {
+		for (unsigned int i = 0; i < sizeof(octets) / sizeof(uint8); i++)
+			if (octets[i] != other.octets[i])
+				return false;
+		return true;
+	}
+
+	bool operator!=(const uint128& other) const {
+		return !(*this == other);
+	}
+
+	/// Assignment
+	uint128& operator=(const uint128 &rhs) {
+		for (unsigned int i = 0; i < sizeof(octets) / sizeof(uint8); i++)
+			octets[i] = rhs.octets[i];
+		return *this;
+	}
+
+	uint128& operator=(uint8 initializer) {
+		for (unsigned int i = 0; i < sizeof(octets) / sizeof(uint8); i++)
+			octets[i] = initializer;
+		return *this;
+	}
+
+	/// Conversion operator
+	operator uint8* () { return &octets[0]; } 
+
+	operator const uint8* () const { return &octets[0]; } 
+
+	uint8 octets[16]; 
+
+} RESTORE_PACK();
+
+#else
+
+typedef PACKED_STRUCT { uint8 octets[16]; } RESTORE_PACK(uint128);
+
+#endif  /// __cplusplus
+#endif
+
+
+///
+/// @brief	Boolean types
+///
+#ifndef true
+#if !defined(__cplusplus)
+	#if defined(WIN32)
+		#if _MSC_VER >= 1310	// VC .NET 2003
+		//typedef int32 bool_type;
+		typedef signed char bool_type;
+		#else
+		typedef signed char bool_type;
+		#endif
+	#elif defined(__LINUX__)
+		typedef signed char bool_type;
+	#elif defined(__linux__)
+		typedef signed char bool_type;
+	#elif defined(__CC_ARM)
+		typedef int32 bool_type;
+	#elif defined(__ICCARM__)
+		typedef uint8 bool_type;
+	#endif
+
+#ifndef TEAKLITE
+	#define true	(1)
+	#define false	(0)
+#endif	
+	#define bool	unsigned char
+#endif	//	!defined(__cplusplus)
+#endif
+
+///
+/// @brief	NULL definition
+///
+#ifndef NULL
+	#define NULL 	0
+#endif // ifndef NULL
+
+///
+/// @brief	Macros for REGISTERS / FIELDS definitions
+///
+
+
+typedef volatile uint8* Reg8Ptr;
+typedef volatile uint16* Reg16Ptr;
+typedef volatile uint32* Reg32Ptr;
+
+
+///
+/// @brief	DECLARE_OPAQUE macro definition. Use in order to export a (void*) type with compiler's
+/// @n		type checking support.
+///
+#ifndef DECLARE_OPAQUE
+#define DECLARE_OPAQUE(name) typedef struct name##__ __##name##__; \
+typedef __##name##__ * name
+#endif
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#endif // _TYPEDEFS_H
+