diff --git a/src/datamodel.c b/src/datamodel.c
index 1708d6fc8d7c33ed46128ca1e1f04836375f8306..b140eea2f84f453e2fd26fe946bd547d98ba1fd1 100644
--- a/src/datamodel.c
+++ b/src/datamodel.c
@@ -30,15 +30,12 @@ DMLEAF tUSBUSBHostsHostDeviceConfigurationInterfaceParams[];
 
 struct usb_port
 {
-	struct uci_section *dm_usb_port;
 	char *folder_name;
 	char *folder_path;
-	struct uci_section *dmsect;
 };
 
 struct usb_interface
 {
-	struct uci_section *dm_usb_iface;
 	char *iface_name;
 	char *iface_path;
 	char *statistics_path;
@@ -49,16 +46,14 @@ struct usb_interface
 /*************************************************************
 * INIT
 *************************************************************/
-static void init_usb_port(struct uci_section *dm, char *folder_name, char *folder_path, struct usb_port *port)
+static void init_usb_port(char *folder_name, char *folder_path, struct usb_port *port)
 {
-	port->dm_usb_port = dm;
 	port->folder_name = dmstrdup(folder_name);
 	port->folder_path = dmstrdup(folder_path);
 }
 
-static void init_usb_interface(struct uci_section *dm, char *iface_name, char *iface_path, char *statistics_path, char *portlink, struct usb_interface *iface)
+static void init_usb_interface(char *iface_name, char *iface_path, char *statistics_path, char *portlink, struct usb_interface *iface)
 {
-	iface->dm_usb_iface = dm;
 	iface->iface_name = dmstrdup(iface_name);
 	iface->iface_path = dmstrdup(iface_path);
 	iface->portlink = dmstrdup(portlink);
@@ -143,6 +138,7 @@ static int browseUSBInterfaceInst(struct dmctx *dmctx, DMNODE *parent_node, void
 	struct usb_interface iface = {0};
 	LIST_HEAD(dup_list);
 	struct sysfs_dmsection *p = NULL;
+	struct dm_data data = {0};
 
 	synchronize_system_folders_with_dmmap_opt(SYSFS_USB_DEVICES_PATH, "dmmap_usb", "dmmap_interface", "usb_iface_link", "usb_iface_instance", &dup_list);
 	list_for_each_entry(p, &dup_list, list) {
@@ -175,11 +171,15 @@ static int browseUSBInterfaceInst(struct dmctx *dmctx, DMNODE *parent_node, void
 			dmuci_set_value_by_section_bbfdm(p->dmmap_section, "usb_iface_path", iface_path);
 
 		snprintf(statistics_path, sizeof(statistics_path), "%s/statistics", iface_path);
-		init_usb_interface(p->dmmap_section, iface_name, iface_path, statistics_path, port_link, &iface);
+		init_usb_interface(iface_name, iface_path, statistics_path, port_link, &iface);
 
 		inst = handle_instance(dmctx, parent_node, p->dmmap_section, "usb_iface_instance", "usb_iface_alias");
 
-		if (DM_LINK_INST_OBJ(dmctx, parent_node, &iface, inst) == DM_STOP)
+		memset(&data, 0, sizeof(struct dm_data));
+		data.dmmap_section = p->dmmap_section;
+		data.additional_data = (void *)&iface;
+
+		if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)&data, inst) == DM_STOP)
 			break;
 	}
 	free_dmmap_config_dup_list(&dup_list);
@@ -194,6 +194,7 @@ static int browseUSBPortInst(struct dmctx *dmctx, DMNODE *parent_node, void *pre
 	LIST_HEAD(dup_list);
 	regex_t regex1 = {};
 	regex_t regex2 = {};
+	struct dm_data data = {0};
 
 	regcomp(&regex1, "^[0-9][0-9]*-[0-9]*[0-9]$", 0);
 	regcomp(&regex2, "^[0-9][0-9]*-[0-9]*[0-9]\\.[0-9]*[0-9]$", 0);
@@ -206,11 +207,15 @@ static int browseUSBPortInst(struct dmctx *dmctx, DMNODE *parent_node, void *pre
 			DM_LSTRSTR(p->sysfs_folder_name, "usb") != p->sysfs_folder_name)
 			continue;
 
-		init_usb_port(p->dmmap_section, p->sysfs_folder_name, p->sysfs_folder_path, &port);
+		init_usb_port(p->sysfs_folder_name, p->sysfs_folder_path, &port);
 
 		inst = handle_instance(dmctx, parent_node, p->dmmap_section, "usb_port_instance", "usb_port_alias");
 
-		if (DM_LINK_INST_OBJ(dmctx, parent_node, &port, inst) == DM_STOP)
+		memset(&data, 0, sizeof(struct dm_data));
+		data.dmmap_section = p->dmmap_section;
+		data.additional_data = (void *)&port;
+
+		if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)&data, inst) == DM_STOP)
 			break;
 	}
 	free_dmmap_config_dup_list(&dup_list);
@@ -225,6 +230,7 @@ static int browseUSBUSBHostsHostInst(struct dmctx *dmctx, DMNODE *parent_node, v
 	char *inst = NULL;
 	struct usb_port port = {0};
 	LIST_HEAD(dup_list);
+	struct dm_data data = {0};
 
 	synchronize_system_folders_with_dmmap_opt(SYSFS_USB_DEVICES_PATH, "dmmap_usb", "dmmap_host", "port_link", "usb_host_instance", &dup_list);
 
@@ -233,12 +239,15 @@ static int browseUSBUSBHostsHostInst(struct dmctx *dmctx, DMNODE *parent_node, v
 		if(!DM_LSTRSTR(p->sysfs_folder_name, "usb"))
 			continue;
 
-		init_usb_port(p->dmmap_section, p->sysfs_folder_name, p->sysfs_folder_path, &port);
-		port.dmsect= p->dmmap_section;
+		init_usb_port(p->sysfs_folder_name, p->sysfs_folder_path, &port);
 
 		inst = handle_instance(dmctx, parent_node, p->dmmap_section, "usb_host_instance", "usb_host_alias");
 
-		if (DM_LINK_INST_OBJ(dmctx, parent_node, &port, inst) == DM_STOP)
+		memset(&data, 0, sizeof(struct dm_data));
+		data.dmmap_section = p->dmmap_section;
+		data.additional_data = (void *)&port;
+
+		if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)&data, inst) == DM_STOP)
 			break;
 	}
 	free_dmmap_config_dup_list(&dup_list);
@@ -322,8 +331,10 @@ static int browseUSBUSBHostsHostDeviceInst(struct dmctx *dmctx, DMNODE *parent_n
 {
 	struct sysfs_dmsection *p = NULL;
 	char *inst = NULL, *parent_host_instance = NULL;
-	struct usb_port *prev_port = (struct usb_port *)prev_data;
+	struct dm_data *prev_node = (struct dm_data *)prev_data;
+	struct usb_port *prev_port = (struct usb_port *)(prev_node->additional_data);
 	LIST_HEAD(dup_list);
+	struct dm_data data = {0};
 
 
 	synchronize_usb_devices_with_dmmap_opt_recursively(prev_port->folder_path,
@@ -332,30 +343,34 @@ static int browseUSBUSBHostsHostDeviceInst(struct dmctx *dmctx, DMNODE *parent_n
 	list_for_each_entry(p, &dup_list, list) {
 		struct usb_port port= {};
 
-		init_usb_port(p->dmmap_section, p->sysfs_folder_name, p->sysfs_folder_path, &port);
+		init_usb_port(p->sysfs_folder_name, p->sysfs_folder_path, &port);
 
-		if (p->dmmap_section && prev_port->dmsect ) {
-			dmuci_get_value_by_section_string(prev_port->dmsect, "usb_host_instance", &parent_host_instance);
+		if (p->dmmap_section && prev_node->dmmap_section ) {
+			dmuci_get_value_by_section_string(prev_node->dmmap_section, "usb_host_instance", &parent_host_instance);
 			dmuci_set_value_by_section_bbfdm(p->dmmap_section, "usb_host_device_parent_host_instance", parent_host_instance);
 		}
 
-		port.dmsect = prev_port->dmsect;
-
 		inst = handle_instance(dmctx, parent_node, p->dmmap_section, "usb_host_device_instance", "usb_host_device_alias");
 
-		if (DM_LINK_INST_OBJ(dmctx, parent_node, &port, inst) == DM_STOP)
+		memset(&data, 0, sizeof(struct dm_data));
+		data.dmmap_section = p->dmmap_section;
+		data.additional_data = (void *)&port;
+
+		if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)&data, inst) == DM_STOP)
 			break;
 	}
-    free_dmmap_config_dup_list(&dup_list);
+	free_dmmap_config_dup_list(&dup_list);
 	return 0;
 }
 
 static int browseUSBUSBHostsHostDeviceConfigurationInst(struct dmctx *dmctx, DMNODE *parent_node, void *prev_data, char *prev_instance)
 {
-	const struct usb_port *usb_dev = prev_data;
+	struct dm_data *prev_node = (struct dm_data *)prev_data;
+	const struct usb_port *usb_dev = (struct usb_port *)(prev_node->additional_data);
 	struct usb_port port = {};
 	struct uci_section *s = NULL;
 	char nbre[16];
+	struct dm_data data = {0};
 
 	__read_sysfs_usb_port(usb_dev, "bNumConfigurations", nbre, sizeof(nbre));
 	if(nbre[0] == '0')
@@ -366,11 +381,15 @@ static int browseUSBUSBHostsHostDeviceConfigurationInst(struct dmctx *dmctx, DMN
 		dmuci_add_section_bbfdm("dmmap_usb", "usb_device_conf", &s);
 	dmuci_set_value_by_section_bbfdm(s, "usb_parent_device", usb_dev->folder_path);
 
-	init_usb_port(s, usb_dev->folder_name, usb_dev->folder_path, &port);
+	init_usb_port(usb_dev->folder_name, usb_dev->folder_path, &port);
 
 	handle_instance(dmctx, parent_node, s, "usb_device_conf_instance", "usb_device_conf_alias");
 
-	DM_LINK_INST_OBJ(dmctx, parent_node, &port, "1");
+	memset(&data, 0, sizeof(struct dm_data));
+	data.dmmap_section = s;
+	data.additional_data = (void *)&port;
+
+	DM_LINK_INST_OBJ(dmctx, parent_node, (void *)&data, "1");
 	return 0;
 }
 
@@ -378,12 +397,14 @@ static int browseUSBUSBHostsHostDeviceConfigurationInterfaceInst(struct dmctx *d
 {
 	DIR *dir = NULL;
 	struct dirent *ent = NULL;
-	struct usb_port *usb_dev = (struct usb_port*)prev_data;
+	struct dm_data *prev_node = (struct dm_data *)prev_data;
+	struct usb_port *usb_dev = (struct usb_port*)(prev_node->additional_data);
 	struct usb_port port = {0};
 	char *sysfs_rep_path, *inst = NULL;
 	struct uci_section *dmmap_sect = NULL;
 	regex_t regex1 = {};
 	regex_t regex2 = {};
+	struct dm_data data = {0};
 
 	regcomp(&regex1, "^[0-9][0-9]*-[0-9]*[0-9]:[0-9][0-9]*\\.[0-9]*[0-9]$", 0);
 	regcomp(&regex2, "^[0-9][0-9]*-[0-9]*[0-9]\\.[0-9]*[0-9]:[0-9][0-9]*\\.[0-9]*[0-9]$", 0);
@@ -400,11 +421,15 @@ static int browseUSBUSBHostsHostDeviceConfigurationInterfaceInst(struct dmctx *d
 				dmuci_set_value_by_section_bbfdm(dmmap_sect, "port_link", sysfs_rep_path);
 			}
 
-			init_usb_port(dmmap_sect, ent->d_name, sysfs_rep_path, &port);
+			init_usb_port(ent->d_name, sysfs_rep_path, &port);
 
 			inst = handle_instance(dmctx, parent_node, dmmap_sect, "usb_device_conf_iface_instance", "usb_device_conf_iface_alias");
 
-			if (DM_LINK_INST_OBJ(dmctx, parent_node, &port, inst) == DM_STOP)
+			memset(&data, 0, sizeof(struct dm_data));
+			data.dmmap_section = dmmap_sect;
+			data.additional_data = (void *)&port;
+
+			if (DM_LINK_INST_OBJ(dmctx, parent_node, (void *)&data, inst) == DM_STOP)
 				break;
 		}
 	}
@@ -435,8 +460,9 @@ static int get_USB_PortNumberOfEntries(char *refparam, struct dmctx *ctx, void *
 static int get_USBInterface_Enable(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char carrier[8];
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_iface(data, "carrier", carrier, sizeof(carrier));
+	__read_sysfs_usb_iface(p->additional_data, "carrier", carrier, sizeof(carrier));
 
 	if (carrier[0] == '1')
 		*value = "1";
@@ -461,8 +487,9 @@ static int set_USBInterface_Enable(char *refparam, struct dmctx *ctx, void *data
 static int get_USBInterface_Status(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char carrier[8];
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_iface(data, "carrier", carrier, sizeof(carrier));
+	__read_sysfs_usb_iface(p->additional_data, "carrier", carrier, sizeof(carrier));
 
 	if (carrier[0] == '1')
 		*value = "Up";
@@ -473,24 +500,31 @@ static int get_USBInterface_Status(char *refparam, struct dmctx *ctx, void *data
 
 static int get_USBInterface_Alias(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return bbf_get_alias(ctx, ((struct usb_interface *)data)->dm_usb_iface, "usb_iface_alias", instance, value);
+	struct dm_data *p = (struct dm_data *)data;
+	return bbf_get_alias(ctx, p->dmmap_section, "usb_iface_alias", instance, value);
 }
 
 static int set_USBInterface_Alias(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
 {
-	return bbf_set_alias(ctx, ((struct usb_interface *)data)->dm_usb_iface, "usb_iface_alias", instance, value);
+	struct dm_data *p = (struct dm_data *)data;
+	return bbf_set_alias(ctx, p->dmmap_section, "usb_iface_alias", instance, value);
 }
 
 static int get_USBInterface_Name(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	struct usb_interface *usbiface= (struct usb_interface *)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_interface *usbiface= (struct usb_interface *)(p->additional_data);
+
 	dmasprintf(value, "%s", usbiface->iface_name);
 	return 0;
 }
 
 static int get_USBInterface_LowerLayers(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	_bbfdm_get_references(ctx, "Device.Ethernet.Interface.", "Name", ((struct usb_interface *)data)->iface_name, value);
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_interface *usbiface= (struct usb_interface *)(p->additional_data);
+
+	_bbfdm_get_references(ctx, "Device.Ethernet.Interface.", "Name", usbiface->iface_name, value);
 	return 0;
 }
 
@@ -509,72 +543,86 @@ static int set_USBInterface_LowerLayers(char *refparam, struct dmctx *ctx, void
 
 static int get_USBInterface_MACAddress(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_iface(data, "address", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_iface(p->additional_data, "address", value);
 }
 
 static int get_USBInterface_MaxBitRate(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_iface(data, "queues/tx-0/tx_maxrate", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_iface(p->additional_data, "queues/tx-0/tx_maxrate", value);
 }
 
 static int get_USBInterfaceStats_BytesSent(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/tx_bytes", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/tx_bytes", value);
 }
 
 static int get_USBInterfaceStats_BytesReceived(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/rx_bytes", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/rx_bytes", value);
 }
 
 static int get_USBInterfaceStats_PacketsSent(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/tx_packets", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/tx_packets", value);
 }
 
 static int get_USBInterfaceStats_PacketsReceived(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/rx_packets", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/rx_packets", value);
 }
 
 static int get_USBInterfaceStats_ErrorsSent(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/tx_errors", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/tx_errors", value);
 }
 
 static int get_USBInterfaceStats_ErrorsReceived(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/rx_errors", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/rx_errors", value);
 }
 
 static int get_USBInterfaceStats_DiscardPacketsSent(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/tx_dropped", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/tx_dropped", value);
 }
 
 static int get_USBInterfaceStats_DiscardPacketsReceived(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/rx_dropped", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/rx_dropped", value);
 }
 
 static int get_USBInterfaceStats_MulticastPacketsReceived(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_net_iface(data, "statistics/multicast", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_net_iface(p->additional_data, "statistics/multicast", value);
 }
 
 static int get_USBPort_Alias(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return bbf_get_alias(ctx, ((struct usb_port *)data)->dm_usb_port, "usb_port_alias", instance, value);
+	struct dm_data *p = (struct dm_data *)data;
+	return bbf_get_alias(ctx, p->dmmap_section, "usb_port_alias", instance, value);
 }
 
 static int set_USBPort_Alias(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
 {
-	return bbf_set_alias(ctx, ((struct usb_port *)data)->dm_usb_port, "usb_port_alias", instance, value);
+	struct dm_data *p = (struct dm_data *)data;
+	return bbf_set_alias(ctx, p->dmmap_section, "usb_port_alias", instance, value);
 }
 
 static int get_USBPort_Name(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	const struct usb_port *port = data;
+	struct dm_data *p = (struct dm_data *)data;
+	const struct usb_port *port = (struct usb_port *)(p->additional_data);
 	*value = dmstrdup(port->folder_name);
 	return 0;
 }
@@ -582,15 +630,17 @@ static int get_USBPort_Name(char *refparam, struct dmctx *ctx, void *data, char
 static int get_USBPort_Standard(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char buf[16];
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_port(data, "bcdDevice", buf, sizeof(buf));
+	__read_sysfs_usb_port(p->additional_data, "bcdDevice", buf, sizeof(buf));
 	dmasprintf(value, "%c.%c", buf[0], buf[0]);
 	return 0;
 }
 
 static int get_USBPort_Type(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	const struct usb_port *port = data;
+	struct dm_data *p = (struct dm_data *)data;
+	const struct usb_port *port = (struct usb_port *)(p->additional_data);
 	char deviceclass[32];
 
 	__read_sysfs_usb_port(port, "bDeviceClass", deviceclass, sizeof(deviceclass));
@@ -607,8 +657,9 @@ static int get_USBPort_Type(char *refparam, struct dmctx *ctx, void *data, char
 static int get_USBPort_Rate(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char speed[16];
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_port(data, "speed", speed, sizeof(speed));
+	__read_sysfs_usb_port(p->additional_data, "speed", speed, sizeof(speed));
 
 	if(DM_LSTRCMP(speed, "1.5") == 0)
 		*value= "Low";
@@ -624,8 +675,9 @@ static int get_USBPort_Rate(char *refparam, struct dmctx *ctx, void *data, char
 static int get_USBPort_Power(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char pwrctl[16];
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_port(data, "power/control", pwrctl, sizeof(pwrctl));
+	__read_sysfs_usb_port(p->additional_data, "power/control", pwrctl, sizeof(pwrctl));
 
 	if (pwrctl[0] == 0)
 		*value = "Unknown";
@@ -646,26 +698,30 @@ static int get_USBUSBHosts_HostNumberOfEntries(char *refparam, struct dmctx *ctx
 
 static int get_USBUSBHostsHost_Alias(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return bbf_get_alias(ctx, ((struct usb_port *)data)->dm_usb_port, "usb_host_alias", instance, value);
+	struct dm_data *p = (struct dm_data *)data;
+	return bbf_get_alias(ctx, p->dmmap_section, "usb_host_alias", instance, value);
 }
 
 static int set_USBUSBHostsHost_Alias(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
 {
-	return bbf_set_alias(ctx, ((struct usb_port *)data)->dm_usb_port, "usb_host_alias", instance, value);
+	struct dm_data *p = (struct dm_data *)data;
+	return bbf_set_alias(ctx, p->dmmap_section, "usb_host_alias", instance, value);
 }
 
 static int get_USBUSBHostsHost_Enable(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char up[32];
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_port(data, "power/wakeup", up, sizeof(up));
+	__read_sysfs_usb_port(p->additional_data, "power/wakeup", up, sizeof(up));
 	*value = DM_LSTRCMP(up, "enabled") == 0 ? "1" : "0";
 	return 0;
 }
 
 static int set_USBUSBHostsHost_Enable(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
 {
-	struct usb_port *usbhost= (struct usb_port *)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_port *usbhost= (struct usb_port *)(p->additional_data);
 	bool b;
 	char *filepath;
 
@@ -688,16 +744,18 @@ static int set_USBUSBHostsHost_Enable(char *refparam, struct dmctx *ctx, void *d
 
 static int get_USBUSBHostsHost_Name(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	struct usb_port* port=(struct usb_port *)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_port* port = (struct usb_port *)(p->additional_data);
 	dmasprintf(value, "%s", port->folder_name);
 	return 0;
 }
 
 static int get_USBUSBHostsHost_Type(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
+	struct dm_data *p = (struct dm_data *)data;
 	char serial[64];
 
-	__read_sysfs_usb_port(data, "serial", serial, sizeof(serial));
+	__read_sysfs_usb_port(p->additional_data, "serial", serial, sizeof(serial));
 
 	if(strcasestr(serial, "ohci")!=NULL)
 		*value= "OHCI";
@@ -712,9 +770,10 @@ static int get_USBUSBHostsHost_Type(char *refparam, struct dmctx *ctx, void *dat
 
 static int get_USBUSBHostsHost_PowerManagementEnable(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
+	struct dm_data *p = (struct dm_data *)data;
 	char power[64] = {0};
 
-	__read_sysfs_usb_port(data, "power/level", power, sizeof(power));
+	__read_sysfs_usb_port(p->additional_data, "power/level", power, sizeof(power));
 
 	if(power[0] == 0 || DM_LSTRCMP(power, "suspend") == 0)
 		*value= "false";
@@ -726,7 +785,8 @@ static int get_USBUSBHostsHost_PowerManagementEnable(char *refparam, struct dmct
 
 static int set_USBUSBHostsHost_PowerManagementEnable(char *refparam, struct dmctx *ctx, void *data, char *instance, char *value, int action)
 {
-	struct usb_port *host= (struct usb_port *)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_port *host= (struct usb_port *)(p->additional_data);
 	bool b;
 
 	switch (action)	{
@@ -748,7 +808,8 @@ static int set_USBUSBHostsHost_PowerManagementEnable(char *refparam, struct dmct
 
 static int get_USBUSBHostsHost_USBVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	const struct usb_port *port = data;
+	struct dm_data *p = (struct dm_data *)data;
+	const struct usb_port *port = (struct usb_port *)(p->additional_data);
 	char file[256];
 	char buf[16] = { 0, 0 };
 
@@ -768,7 +829,8 @@ static int get_USBUSBHostsHost_DeviceNumberOfEntries(char *refparam, struct dmct
 
 static int get_USBUSBHostsHostDevice_DeviceNumber(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	struct usb_port *usbdev = (struct usb_port *)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_port *usbdev = (struct usb_port *)(p->additional_data);
 	size_t length;
 	char **filename = strsplit(usbdev->folder_name, "-", &length);
 	char **port = strsplit(filename[1], ".", &length);
@@ -778,31 +840,36 @@ static int get_USBUSBHostsHostDevice_DeviceNumber(char *refparam, struct dmctx *
 
 static int get_USBUSBHostsHostDevice_USBVersion(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bcdDevice", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bcdDevice", value);
 }
 
 static int get_USBUSBHostsHostDevice_DeviceClass(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bDeviceClass", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bDeviceClass", value);
 }
 
 static int get_USBUSBHostsHostDevice_DeviceSubClass(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bDeviceSubClass", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bDeviceSubClass", value);
 }
 
 static int get_USBUSBHostsHostDevice_DeviceProtocol(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bDeviceProtocol", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bDeviceProtocol", value);
 }
 
 static int get_USBUSBHostsHostDevice_ProductID(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char *idproduct = NULL;
 	unsigned int ui_idproduct;
+	struct dm_data *p = (struct dm_data *)data;
 
 	*value = "0";
-	int rc = read_sysfs_usb_port(data, "idProduct", &idproduct);
+	int rc = read_sysfs_usb_port(p->additional_data, "idProduct", &idproduct);
 
 	if (rc != -1 && idproduct != NULL) {
 		sscanf(idproduct, "%x", &ui_idproduct);
@@ -815,9 +882,10 @@ static int get_USBUSBHostsHostDevice_VendorID(char *refparam, struct dmctx *ctx,
 {
 	char *idvendor = NULL;
 	unsigned int ui_idvendor;
+	struct dm_data *p = (struct dm_data *)data;
 
 	*value = "0";
-	int rc = read_sysfs_usb_port(data, "idVendor", &idvendor);
+	int rc = read_sysfs_usb_port(p->additional_data, "idVendor", &idvendor);
 
 	if (rc != -1 && idvendor != NULL) {
 		sscanf(idvendor, "%x", &ui_idvendor);
@@ -828,22 +896,26 @@ static int get_USBUSBHostsHostDevice_VendorID(char *refparam, struct dmctx *ctx,
 
 static int get_USBUSBHostsHostDevice_Manufacturer(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "manufacturer", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "manufacturer", value);
 }
 
 static int get_USBUSBHostsHostDevice_ProductClass(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "product", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "product", value);
 }
 
 static int get_USBUSBHostsHostDevice_SerialNumber(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "urbnum", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "urbnum", value);
 }
 
 static int get_USBUSBHostsHostDevice_Port(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	struct usb_port *port= (struct usb_port *)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_port *port= (struct usb_port *)(p->additional_data);
 	size_t length;
 	char **busname, **portname;
 	regex_t regex1 = {};
@@ -866,7 +938,8 @@ out:
 
 static int get_USBUSBHostsHostDevice_USBPort(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	_bbfdm_get_references(ctx, "Device.USB.Port.", "Name", ((struct usb_port *)data)->folder_name, value);
+	struct dm_data *p = (struct dm_data *)data;
+	_bbfdm_get_references(ctx, "Device.USB.Port.", "Name", ((struct usb_port *)(p->additional_data))->folder_name, value);
 	return 0;
 }
 
@@ -877,13 +950,14 @@ static int get_USBUSBHostsHostDevice_Rate(char *refparam, struct dmctx *ctx, voi
 
 static int get_USBUSBHostsHostDevice_Parent(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	struct usb_port *usbdev = (struct usb_port*)data;
+	struct dm_data *p = (struct dm_data *)data;
+	struct usb_port *usbdev = (struct usb_port*)(p->additional_data);
 	char *host_inst, usb_host_path[128] = {0};
 	regex_t regex1 = {0};
 	size_t length;
 
 	regcomp(&regex1, "^[0-9][0-9]*-[0-9]*[0-9]\\.[0-9]*[0-9]$", 0);
-	if (regexec(&regex1, usbdev->folder_name, 0, NULL, 0) != 0 || usbdev->dmsect == NULL) {
+	if (regexec(&regex1, usbdev->folder_name, 0, NULL, 0) != 0 || p->dmmap_section == NULL) {
 		*value = "";
 		goto out;
 	}
@@ -895,7 +969,7 @@ static int get_USBUSBHostsHostDevice_Parent(char *refparam, struct dmctx *ctx, v
 		goto out;
 	}
 
-	dmuci_get_value_by_section_string(usbdev->dmsect, "usb_host_instance", &host_inst);
+	dmuci_get_value_by_section_string(p->dmmap_section, "usb_host_instance", &host_inst);
 	snprintf(usb_host_path, sizeof(usb_host_path), "Device.USB.USBHosts.Host.%s.Device.", host_inst);
 
 	_bbfdm_get_references(ctx, usb_host_path, "DeviceNumber", port[0], value);
@@ -907,14 +981,16 @@ out:
 
 static int get_USBUSBHostsHostDevice_MaxChildren(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "maxchild", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "maxchild", value);
 }
 
 static int get_USBUSBHostsHostDevice_IsSuspended(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
 	char status[16] = {0};
+	struct dm_data *p = (struct dm_data *)data;
 
-	__read_sysfs_usb_port(data, "power/runtime_status", status, sizeof(status));
+	__read_sysfs_usb_port(p->additional_data, "power/runtime_status", status, sizeof(status));
 	if(DM_LSTRNCMP(status, "suspended", 9) == 0)
 		*value= "1";
 	else
@@ -924,37 +1000,44 @@ static int get_USBUSBHostsHostDevice_IsSuspended(char *refparam, struct dmctx *c
 
 static int get_USBUSBHostsHostDevice_ConfigurationNumberOfEntries(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bNumConfigurations", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bNumConfigurations", value);
 }
 
 static int get_USBUSBHostsHostDeviceConfiguration_ConfigurationNumber(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bConfigurationValue", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bConfigurationValue", value);
 }
 
 static int get_USBUSBHostsHostDeviceConfiguration_InterfaceNumberOfEntries(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bNumInterfaces", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bNumInterfaces", value);
 }
 
 static int get_USBUSBHostsHostDeviceConfigurationInterface_InterfaceNumber(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bInterfaceNumber", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bInterfaceNumber", value);
 }
 
 static int get_USBUSBHostsHostDeviceConfigurationInterface_InterfaceClass(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bInterfaceClass", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bInterfaceClass", value);
 }
 
 static int get_USBUSBHostsHostDeviceConfigurationInterface_InterfaceSubClass(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bInterfaceSubClass", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bInterfaceSubClass", value);
 }
 
 static int get_USBUSBHostsHostDeviceConfigurationInterface_InterfaceProtocol(char *refparam, struct dmctx *ctx, void *data, char *instance, char **value)
 {
-	return read_sysfs_usb_port(data, "bInterfaceProtocol", value);
+	struct dm_data *p = (struct dm_data *)data;
+	return read_sysfs_usb_port(p->additional_data, "bInterfaceProtocol", value);
 }
 
 /**********************************************************************************************************************************