0001-merge-to-https-github.com-linux-usb-gadgets-libusbgx.patch

index 519b012..4eaa563 100644
--- a/src/function/ms.c
+++ b/src/function/ms.c
@@ -64,6 +64,7 @@ static struct {
 	[USBG_F_MS_LUN_NOFUA] = MS_LUN_BOOL_ATTR(nofua),
 	[USBG_F_MS_LUN_REMOVABLE] = MS_LUN_BOOL_ATTR(removable),
 	[USBG_F_MS_LUN_FILE] = MS_LUN_STRING_ATTR(file),
+	[USBG_F_MS_LUN_INQUIRY_STRING] = MS_LUN_STRING_ATTR(inquiry_string),
 };
 
 static inline int lun_select(const struct dirent *dent)
diff --git a/src/function/printer.c b/src/function/printer.c
new file mode 100644
index 0000000..7270dd6
--- /dev/null
+++ b/src/function/printer.c
@@ -0,0 +1,34 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ */
+
+#include "usbg/usbg.h"
+#include "usbg/usbg_internal.h"
+
+#ifdef HAS_GADGET_SCHEMES
+#include <libconfig.h>
+#endif
+
+struct usbg_f_printer {
+	struct usbg_function func;
+};
+
+GENERIC_ALLOC_INST(printer, struct usbg_f_printer, func);
+
+GENERIC_FREE_INST(printer, struct usbg_f_printer, func);
+
+#define PRINTER_FUNCTION_OPTS			\
+	.alloc_inst = printer_alloc_inst,	\
+	.free_inst = printer_free_inst
+
+struct usbg_function_type usbg_f_type_printer = {
+    .name = "printer",
+    PRINTER_FUNCTION_OPTS};
diff --git a/src/function/uac2.c b/src/function/uac2.c
index f2c1a49..9ca8b66 100644
--- a/src/function/uac2.c
+++ b/src/function/uac2.c
@@ -23,6 +23,26 @@ struct usbg_f_uac2 {
 	struct usbg_function func;
 };
 
+#define UAC2_BOOL_ATTR(_name)						\
+	{								\
+		.name = #_name,						\
+		.offset = offsetof(struct usbg_f_uac2_attrs, _name),    \
+		.get = usbg_get_bool,				        \
+		.set = usbg_set_bool,				        \
+		.import = usbg_get_config_node_bool,	                \
+		.export = usbg_set_config_node_bool,		        \
+	}
+
+#define UAC2_STRING_ATTR(_name)					\
+	{								\
+		.name = #_name,						\
+		.offset = offsetof(struct usbg_f_uac2_attrs, _name),     \
+		.get = usbg_get_string,				        \
+		.set = usbg_set_string,				        \
+		.export = usbg_set_config_node_string,		        \
+		.import = usbg_get_config_node_string,	                \
+	}
+
 #define UAC2_DEC_ATTR(_name)						\
 	{								\
 		.name = #_name,						\
@@ -47,6 +67,22 @@ static struct {
 	[USBG_F_UAC2_P_CHMASK] = UAC2_DEC_ATTR(p_chmask),
 	[USBG_F_UAC2_P_SRATE] = UAC2_DEC_ATTR(p_srate),
 	[USBG_F_UAC2_P_SSIZE] = UAC2_DEC_ATTR(p_ssize),
+	[USBG_F_UAC2_P_HS_BINT] = UAC2_DEC_ATTR(p_hs_bint),
+	[USBG_F_UAC2_C_HS_BINT] = UAC2_DEC_ATTR(c_hs_bint),
+	[USBG_F_UAC2_C_SYNC] = UAC2_STRING_ATTR(c_sync),
+	[USBG_F_UAC2_REQ_NUMBER] = UAC2_DEC_ATTR(req_number),
+	[USBG_F_UAC2_FB_MAX] = UAC2_DEC_ATTR(fb_max),
+	[USBG_F_UAC2_P_MUTE_PRESENT] = UAC2_BOOL_ATTR(p_mute_present),
+	[USBG_F_UAC2_P_VOLUME_PRESENT] = UAC2_BOOL_ATTR(p_volume_present),
+	[USBG_F_UAC2_P_VOLUME_MIN] = UAC2_DEC_ATTR(p_volume_min),
+	[USBG_F_UAC2_P_VOLUME_MAX] = UAC2_DEC_ATTR(p_volume_max),
+	[USBG_F_UAC2_P_VOLUME_RES] = UAC2_DEC_ATTR(p_volume_res),
+	[USBG_F_UAC2_C_MUTE_PRESENT] = UAC2_BOOL_ATTR(c_mute_present),
+	[USBG_F_UAC2_C_VOLUME_PRESENT] = UAC2_BOOL_ATTR(c_volume_present),
+	[USBG_F_UAC2_C_VOLUME_MIN] = UAC2_DEC_ATTR(c_volume_min),
+	[USBG_F_UAC2_C_VOLUME_MAX] = UAC2_DEC_ATTR(c_volume_max),
+	[USBG_F_UAC2_C_VOLUME_RES] = UAC2_DEC_ATTR(c_volume_res),
+	[USBG_F_UAC2_FUNCTION_NAME] = UAC2_STRING_ATTR(function_name),
 };
 
 #undef UAC2_DEC_ATTR
diff --git a/src/function/uvc.c b/src/function/uvc.c
new file mode 100644
index 0000000..f39594b
--- /dev/null
+++ b/src/function/uvc.c
@@ -0,0 +1,1219 @@
+/*
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ */
+
+#include "usbg/usbg.h"
+#include "usbg/usbg_internal.h"
+#include "usbg/function/uvc.h"
+
+#include <errno.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <ftw.h>
+#ifdef HAS_GADGET_SCHEMES
+#include <libconfig.h>
+#endif
+
+#define UVC_PATH_CONTROL		"control"
+#define UVC_PATH_HEADER			"header/h"
+#define UVC_PATH_CLASS_FS		"class/fs/h"
+#define UVC_PATH_CLASS_HS		"class/hs/h"
+#define UVC_PATH_CLASS_SS		"class/ss/h"
+#define UVC_PATH_STREAMING		"streaming"
+#define UVC_PATH_STREAMING_UNCOMPRESSED	"uncompressed/u"
+#define UVC_PATH_STREAMING_MJPEG	"mjpeg/m"
+
+#define MAX_FRAMES 16
+#define MAX_FORMATS 2
+
+const char * format_names[MAX_FORMATS] = {
+	UVC_PATH_STREAMING_MJPEG,
+	UVC_PATH_STREAMING_UNCOMPRESSED,
+};
+
+struct formats {
+	bool frames[MAX_FRAMES];
+	bool frames_initiated;
+};
+
+struct usbg_f_uvc
+{
+	struct usbg_function func;
+	struct formats formats[MAX_FORMATS];
+	bool formats_initiated;
+};
+
+#define UVC_DEC_ATTR(_name)						\
+	{								\
+		.name = #_name,						\
+		.offset = offsetof(struct usbg_f_uvc_config_attrs, _name),     \
+		.get = usbg_get_dec,				        \
+		.set = usbg_set_dec,				        \
+		.import = usbg_get_config_node_int,	                \
+		.export = usbg_set_config_node_int,		        \
+	}
+
+#define UVC_STRING_ATTR(_name)					\
+	{								\
+		.name = #_name,						\
+		.offset = offsetof(struct usbg_f_uvc_config_attrs, _name),     \
+		.get = usbg_get_string,				        \
+		.set = usbg_set_string,				        \
+		.export = usbg_set_config_node_string,		        \
+		.import = usbg_get_config_node_string,	                \
+	}
+
+struct {
+	const char *name;
+	size_t offset;
+	usbg_attr_get_func get;
+	usbg_attr_set_func set;
+	usbg_import_node_func import;
+	usbg_export_node_func export;
+} uvc_config_attr[USBG_F_UVC_CONFIG_ATTR_MAX] = {
+	[USBG_F_UVC_CONFIG_MAXBURST] = UVC_DEC_ATTR(streaming_maxburst),
+	[USBG_F_UVC_CONFIG_MAXPACKET] = UVC_DEC_ATTR(streaming_maxpacket),
+	[USBG_F_UVC_CONFIG_INTERVAL] = UVC_DEC_ATTR(streaming_interval),
+	[USBG_F_UVC_CONFIG_FUNCTION_NAME] = UVC_STRING_ATTR(function_name),
+};
+
+#undef UVC_DEC_ATTR
+
+#define UVC_DEC_ATTR(_name)						\
+	{								\
+		.name = #_name,						\
+		.offset = offsetof(struct usbg_f_uvc_frame_attrs, _name),     \
+		.get = usbg_get_dec,				        \
+		.set = usbg_set_dec,				        \
+		.import = usbg_get_config_node_int,	                \
+		.export = usbg_set_config_node_int,		        \
+	}
+
+struct {
+	const char *name;
+	size_t offset;
+	usbg_attr_get_func get;
+	usbg_attr_set_func set;
+	usbg_import_node_func import;
+	usbg_export_node_func export;
+} uvc_frame_attr[USBG_F_UVC_FRAME_ATTR_MAX] = {
+	[USBG_F_UVC_FRAME_INDEX] = UVC_DEC_ATTR(bFrameIndex),
+	[USBG_F_UVC_FRAME_CAPABILITIES] = UVC_DEC_ATTR(bmCapabilities),
+	[USBG_F_UVC_FRAME_MIN_BITRATE] = UVC_DEC_ATTR(dwMinBitRate),
+	[USBG_F_UVC_FRAME_MAX_BITRATE] = UVC_DEC_ATTR(dwMaxBitRate),
+	[USBG_F_UVC_FRAME_MAX_VIDEO_BUFFERSIZE] = UVC_DEC_ATTR(dwMaxVideoFrameBufferSize),
+	[USBG_F_UVC_FRAME_DEFAULT_INTERVAL] = UVC_DEC_ATTR(dwDefaultFrameInterval),
+	[USBG_F_UVC_FRAME_INTERVAL] = UVC_DEC_ATTR(dwFrameInterval),
+	[USBG_F_UVC_FRAME_HEIGHT] = UVC_DEC_ATTR(wHeight),
+	[USBG_F_UVC_FRAME_WIDTH] = UVC_DEC_ATTR(wWidth),
+};
+
+#undef UVC_DEC_ATTR
+
+#define UVC_DEC_ATTR(_name)						\
+	{								\
+		.name = #_name,						\
+		.offset = offsetof(struct usbg_f_uvc_format_attrs, _name),     \
+		.get = usbg_get_dec,				        \
+		.set = usbg_set_dec,				        \
+		.import = usbg_get_config_node_int,	                \
+		.export = usbg_set_config_node_int,		        \
+	}
+
+#define UVC_DEC_ATTR_RO(_name)						\
+	{								\
+		.name = #_name,						\
+		.ro = true,						\
+		.offset = offsetof(struct usbg_f_uvc_format_attrs, _name),     \
+		.get = usbg_get_dec,				        \
+		.export = usbg_set_config_node_int,		        \
+	}
+
+struct {
+	const char *name;
+	size_t offset;
+	bool ro;
+	usbg_attr_get_func get;
+	usbg_attr_set_func set;
+	usbg_import_node_func import;
+	usbg_export_node_func export;
+} uvc_format_attr[USBG_F_UVC_FORMAT_ATTR_MAX] = {
+	[USBG_F_UVC_FORMAT_CONTROLS] = UVC_DEC_ATTR_RO(bmaControls),
+	[USBG_F_UVC_FORMAT_INTERFACE_FLAGS] = UVC_DEC_ATTR_RO(bmInterfaceFlags),
+	[USBG_F_UVC_FORMAT_ASPECTRATIO_X] = UVC_DEC_ATTR_RO(bAspectRatioX),
+	[USBG_F_UVC_FORMAT_ASPECTRATIO_Y] = UVC_DEC_ATTR_RO(bAspectRatioY),
+	[USBG_F_UVC_FORMAT_DEFAULT_FRAME_INDEX] = UVC_DEC_ATTR(bDefaultFrameIndex),
+	[USBG_F_UVC_FORMAT_FORMAT_INDEX] = UVC_DEC_ATTR_RO(bFormatIndex),
+};
+
+
+#undef UVC_DEC_ATTR
+#undef UVC_DEC_ATTR_RO
+
+static inline int frame_select(const struct dirent *dent)
+{
+	int ret;
+	int id;
+
+	ret = file_select(dent);
+	if (!ret)
+		goto out;
+
+	ret = sscanf(dent->d_name, "frame.%d", &id);
+out:
+	return ret;
+}
+
+static inline int frame_sort(const struct dirent **d1, const struct dirent **d2)
+{
+	int ret;
+	int id1, id2;
+
+	ret = sscanf((*d1)->d_name, "frame.%d", &id1);
+	if (ret != 1)
+		goto err;
+
+	ret = sscanf((*d2)->d_name, "frame.%d", &id2);
+	if (ret != 1)
+		goto err;
+
+	return id1 < id2 ? -1 : id1 > id2;
+err:
+	/*
+	 * This should not happened because dentries has been
+	 * already checked by frame_select function. This
+	 * error procedure is just in case.
+	 */
+	return -1;
+}
+
+int init_frames(struct usbg_f_uvc *uvc, int j)
+{
+	struct dirent **dent;
+	char fpath[USBG_MAX_PATH_LENGTH];
+	int nmb, i, id, ret = 0;
+
+	nmb = snprintf(fpath, sizeof(fpath), "%s/%s/" UVC_PATH_STREAMING "/%s/",
+		       uvc->func.path, uvc->func.name, format_names[j]);
+	if (nmb >= sizeof(fpath)) {
+		ret = USBG_ERROR_PATH_TOO_LONG;
+		return ret;
+	}
+
+	nmb = scandir(fpath, &dent, frame_select, frame_sort);
+	if (nmb < 0) {
+		ret = usbg_translate_error(errno);
+		return ret;
+	}
+
+	for (i = 0; i < nmb; ++i) {
+		/* don't check the error as we know that name is valid */
+		sscanf(dent[i]->d_name, "frame.%d", &id);
+		uvc->formats[j].frames[id] = true;
+		free(dent[i]);
+	}
+	free(dent);
+
+	uvc->formats[j].frames_initiated = true;
+
+	return 0;
+}
+
+static inline struct formats *get_formats_mask(struct usbg_f_uvc *uvc)
+{
+	int i, ret;
+
+	if (!uvc->formats_initiated) {
+		uvc->formats_initiated = true;
+		for (i = 0; i < MAX_FORMATS; ++i) {
+			ret = init_frames(uvc, i);
+			if (ret)
+				uvc->formats_initiated = false;
+		}
+	}
+
+	return uvc->formats;
+}
+
+GENERIC_ALLOC_INST(uvc_internal, struct usbg_f_uvc, func);
+static int uvc_alloc_inst(struct usbg_function_type *type,
+			 usbg_function_type type_code,
+			 const char *instance, const char *path,
+			 struct usbg_gadget *parent,
+			 struct usbg_function **f)
+{
+	struct usbg_f_uvc *uvcf;
+	int ret;
+
+	ret = uvc_internal_alloc_inst(type, type_code, instance,
+				     path, parent, f);
+	if (ret)
+		goto out;
+
+	uvcf = usbg_to_uvc_function(*f);
+	if (!uvcf)
+		return -ENOMEM;
+
+	memset(uvcf->formats, 0, sizeof(uvcf->formats));
+	uvcf->formats_initiated = false;
+out:
+	return ret;
+}
+
+GENERIC_FREE_INST(uvc, struct usbg_f_uvc, func);
+
+static int uvc_set_attrs(struct usbg_function *f, void *f_attrs)
+{
+	return usbg_f_uvc_set_attrs(usbg_to_uvc_function(f), f_attrs);
+}
+
+static int uvc_get_attrs(struct usbg_function *f, void *f_attrs)
+{
+	return usbg_f_uvc_get_attrs(usbg_to_uvc_function(f), f_attrs);
+}
+
+static void uvc_cleanup_attrs(struct usbg_function *f, void *f_attrs)
+{
+	return usbg_f_uvc_cleanup_attrs(f_attrs);
+}
+
+int usbg_f_uvc_get_config_attr_val(usbg_f_uvc *uvcf, enum usbg_f_uvc_config_attr iattr,
+			       union usbg_f_uvc_config_attr_val *val)
+{
+	char ipath[USBG_MAX_PATH_LENGTH];
+	int nmb;
+
+	nmb = snprintf(ipath, sizeof(ipath), "%s/%s/",
+		       uvcf->func.path, uvcf->func.name);
+	if (nmb >= sizeof(ipath))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+
+	return uvc_config_attr[iattr].get(ipath, "",
+				    uvc_config_attr[iattr].name, val);
+}
+
+int usbg_f_uvc_set_config_attr_val(usbg_f_uvc *uvcf, enum usbg_f_uvc_config_attr iattr,
+			       union usbg_f_uvc_config_attr_val val)
+{
+	char ipath[USBG_MAX_PATH_LENGTH];
+	int nmb;
+
+	nmb = snprintf(ipath, sizeof(ipath), "%s/%s/",
+		       uvcf->func.path, uvcf->func.name);
+	if (nmb >= sizeof(ipath))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	return uvc_config_attr[iattr].set(ipath, "",
+				       uvc_config_attr[iattr].name, &val);
+}
+
+int usbg_f_uvc_get_config_attrs(usbg_f_uvc *uvcf, struct usbg_f_uvc_config_attrs *iattrs)
+{
+	int i;
+	int ret = 0;
+
+	for (i = USBG_F_UVC_CONFIG_ATTR_MIN; i < USBG_F_UVC_CONFIG_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_get_config_attr_val(uvcf, i,
+					       (union usbg_f_uvc_config_attr_val *)
+					       ((char *)iattrs
+						+ uvc_config_attr[i].offset));
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+int usbg_f_uvc_set_config_attrs(usbg_f_uvc *uvcf, const struct usbg_f_uvc_config_attrs *iattrs)
+{
+	int i;
+	int ret = 0;
+
+	for (i = USBG_F_UVC_FRAME_ATTR_MIN; i < USBG_F_UVC_FRAME_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_set_config_attr_val(uvcf, i,
+					       *(union usbg_f_uvc_config_attr_val *)
+					       ((char *)iattrs
+						+ uvc_config_attr[i].offset));
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+int usbg_f_uvc_get_frame_attr_val(usbg_f_uvc *uvcf, const char* format, int frame_id,
+			       enum usbg_f_uvc_frame_attr fattr,
+			       union usbg_f_uvc_frame_attr_val *val)
+{
+	char fpath[USBG_MAX_PATH_LENGTH];
+	int nmb;
+
+	nmb = snprintf(fpath, sizeof(fpath), "%s/%s/" UVC_PATH_STREAMING "/%s/frame.%d/",
+		       uvcf->func.path, uvcf->func.name, format, frame_id);
+	if (nmb >= sizeof(fpath))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	return uvc_frame_attr[fattr].get(fpath, "",
+				    uvc_frame_attr[fattr].name, val);
+}
+
+int usbg_f_uvc_set_frame_attr_val(usbg_f_uvc *uvcf, const char* format, int frame_id,
+			       enum usbg_f_uvc_frame_attr fattr,
+			       union usbg_f_uvc_frame_attr_val val)
+{
+	char fpath[USBG_MAX_PATH_LENGTH];
+	int nmb;
+
+	nmb = snprintf(fpath, sizeof(fpath), "%s/%s/" UVC_PATH_STREAMING "/%s/frame.%d/",
+		       uvcf->func.path, uvcf->func.name, format, frame_id);
+	if (nmb >= sizeof(fpath))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	return uvc_frame_attr[fattr].set(fpath, "",
+				       uvc_frame_attr[fattr].name, &val);
+}
+
+int usbg_f_uvc_get_frame_attrs(usbg_f_uvc *uvcf, const char* format, int frame_id,
+			struct usbg_f_uvc_frame_attrs *fattrs)
+{
+	int i;
+	int ret = 0;
+
+	for (i = USBG_F_UVC_FRAME_ATTR_MIN; i < USBG_F_UVC_FRAME_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_get_frame_attr_val(uvcf, format, frame_id, i,
+					       (union usbg_f_uvc_frame_attr_val *)
+					       ((char *)fattrs
+						+ uvc_frame_attr[i].offset));
+		if (ret)
+			break;
+	}
+
+	fattrs->bFrameIndex = frame_id;
+
+	return ret;
+}
+
+int usbg_f_uvc_set_frame_attrs(usbg_f_uvc *uvcf, const char* format, int frame_id,
+			    const struct usbg_f_uvc_frame_attrs *fattrs)
+{
+	int i;
+	int ret = 0;
+
+	for (i = USBG_F_UVC_FRAME_ATTR_MIN; i < USBG_F_UVC_FRAME_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_set_frame_attr_val(uvcf, format, frame_id, i,
+					       *(union usbg_f_uvc_frame_attr_val *)
+					       ((char *)fattrs
+						+ uvc_frame_attr[i].offset));
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+int usbg_f_uvc_get_format_attr_val(usbg_f_uvc *uvcf, const char* format,
+			       enum usbg_f_uvc_format_attr fattr,
+			       union usbg_f_uvc_format_attr_val *val)
+{
+	char fpath[USBG_MAX_PATH_LENGTH];
+	int nmb;
+
+	nmb = snprintf(fpath, sizeof(fpath), "%s/%s/" UVC_PATH_STREAMING "/%s/",
+		       uvcf->func.path, uvcf->func.name, format);
+	if (nmb >= sizeof(fpath))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	return uvc_format_attr[fattr].get(fpath, "",
+				    uvc_format_attr[fattr].name, val);
+}
+
+int usbg_f_uvc_set_format_attr_val(usbg_f_uvc *uvcf, const char* format,
+			       enum usbg_f_uvc_format_attr fattr,
+			       union usbg_f_uvc_format_attr_val val)
+{
+	char fpath[USBG_MAX_PATH_LENGTH];
+	int nmb;
+
+	nmb = snprintf(fpath, sizeof(fpath), "%s/%s/" UVC_PATH_STREAMING "/%s/",
+		       uvcf->func.path, uvcf->func.name, format);
+	if (nmb >= sizeof(fpath))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	return uvc_format_attr[fattr].set(fpath, "",
+				       uvc_format_attr[fattr].name, &val);
+}
+
+int usbg_f_uvc_get_format_attrs(usbg_f_uvc *uvcf, const char* format,
+			struct usbg_f_uvc_format_attrs *fattrs)
+{
+	int i;
+	int ret = 0;
+
+	for (i = USBG_F_UVC_FORMAT_ATTR_MIN; i < USBG_F_UVC_FORMAT_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_get_format_attr_val(uvcf, format, i,
+					       (union usbg_f_uvc_format_attr_val *)
+					       ((char *)fattrs
+						+ uvc_format_attr[i].offset));
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+int usbg_f_uvc_set_format_attrs(usbg_f_uvc *uvcf, const char* format,
+			    const struct usbg_f_uvc_format_attrs *fattrs)
+{
+	int i;
+	int ret = 0;
+
+	for (i = USBG_F_UVC_FORMAT_ATTR_MIN; i < USBG_F_UVC_FORMAT_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_set_format_attr_val(uvcf, format, i,
+					       *(union usbg_f_uvc_format_attr_val *)
+					       ((char *)fattrs
+						+ uvc_format_attr[i].offset));
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+static int uvc_create_dir(const char *path)
+{
+	char tmp[USBG_MAX_PATH_LENGTH];
+	int nmb, ret = USBG_SUCCESS;
+	char *p = NULL;
+	size_t len;
+
+	nmb = snprintf(tmp, sizeof(tmp), "%s", path);
+	if(nmb >= sizeof(tmp))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	len = strlen(tmp);
+	if(tmp[len - 1] == '/')
+		tmp[len - 1] = 0;
+
+	for (p = tmp + 1; *p; p++) {
+		if(*p == '/') {
+			*p = 0;
+			if((mkdir(tmp, S_IRWXU | S_IRWXG | S_IRWXO) != 0) && errno != EEXIST) {
+				ret = usbg_translate_error(errno);
+				break;
+			}
+			*p = '/';
+		}
+	}
+	if(ret != USBG_SUCCESS)
+		return ret;
+
+	if((mkdir(tmp, S_IRWXU | S_IRWXG | S_IRWXO) != 0) && errno != EEXIST)
+		return usbg_translate_error(errno);
+
+	return ret;
+}
+
+static int uvc_link(char *path, char *to, char *from)
+{
+	char oldname[USBG_MAX_PATH_LENGTH];
+	char newname[USBG_MAX_PATH_LENGTH];
+	int ret = USBG_SUCCESS;
+	int nmb;
+
+	nmb = snprintf(oldname, sizeof(oldname), "%s/%s", path, to);
+	if (nmb >= sizeof(oldname))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	nmb = snprintf(newname, sizeof(newname), "%s/%s", path, from);
+	if (nmb >= sizeof(newname))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	if(symlink(oldname, newname))
+		return usbg_translate_error(errno);
+
+	return ret;
+}
+
+static int uvc_set_class(usbg_f_uvc *uvcf, char *cs)
+{
+	char path[USBG_MAX_PATH_LENGTH];
+	char header_path[USBG_MAX_PATH_LENGTH];
+	int nmb;
+	int ret;
+
+	nmb = snprintf(path, sizeof(path), "%s/%s/%s", uvcf->func.path, uvcf->func.name, cs);
+	if (nmb >= sizeof(path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	nmb = snprintf(header_path, sizeof(header_path), "%s/" UVC_PATH_HEADER, path);
+	if (nmb >= sizeof(header_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	ret = uvc_create_dir(header_path);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	if (!strncmp(cs, UVC_PATH_STREAMING, strlen(UVC_PATH_STREAMING))) {
+		char check_path[USBG_MAX_PATH_LENGTH];
+		struct stat buffer;
+
+		nmb = snprintf(check_path, sizeof(check_path), "%s/" UVC_PATH_STREAMING_UNCOMPRESSED, path);
+		if (nmb >= sizeof(check_path))
+			return USBG_ERROR_PATH_TOO_LONG;
+
+		ret = stat(check_path, &buffer);
+		if (!ret) {
+			ret = uvc_link(path, UVC_PATH_STREAMING_UNCOMPRESSED, "header/h/u");
+			if (ret != USBG_SUCCESS)
+				return ret;
+		}
+
+		nmb = snprintf(check_path, sizeof(check_path), "%s/" UVC_PATH_STREAMING_MJPEG, path);
+		if (nmb >= sizeof(check_path))
+			return USBG_ERROR_PATH_TOO_LONG;
+
+		ret = stat(check_path, &buffer);
+		if (!ret) {
+			ret = uvc_link(path, UVC_PATH_STREAMING_MJPEG, "header/h/m");
+			if (ret != USBG_SUCCESS)
+				return ret;
+		}
+
+		ret = uvc_link(path, UVC_PATH_HEADER, UVC_PATH_CLASS_HS);
+		if (ret)
+			return ret;
+	}
+
+	ret = uvc_link(path, UVC_PATH_HEADER, UVC_PATH_CLASS_FS);
+	if (ret)
+		return ret;
+
+	return uvc_link(path, UVC_PATH_HEADER, UVC_PATH_CLASS_SS);
+}
+
+#ifdef HAS_GADGET_SCHEMES
+
+int usbg_f_uvc_get_nframes(const bool *frames)
+{
+	int nframes = 0;
+	int i;
+
+	if (!frames)
+		return USBG_ERROR_INVALID_PARAM;
+
+	for (i = 0; i < MAX_FRAMES; ++i)
+		nframes += frames[i] ? 1 : 0;
+
+	return nframes;
+}
+
+int usbg_f_uvc_create_frame(usbg_f_uvc *uvcf, const char* format, bool *frames,
+			 int frame_id, struct usbg_f_uvc_frame_attrs *fattrs)
+{
+	char frame_path[USBG_MAX_PATH_LENGTH];
+	int nmb;
+	int ret;
+
+	if (frame_id >= MAX_FRAMES)
+		return USBG_ERROR_INVALID_PARAM;
+
+	if (frames[frame_id])
+		return USBG_ERROR_EXIST;
+
+	nmb = snprintf(frame_path, sizeof(frame_path), "%s/%s/" UVC_PATH_STREAMING "/%s/frame.%d/",
+		       uvcf->func.path, uvcf->func.name, format, frame_id);
+	if (nmb >= sizeof(frame_path))
+		return USBG_ERROR_PATH_TOO_LONG;
+
+	ret = uvc_create_dir(frame_path);
+	if (ret)
+		return usbg_translate_error(errno);
+
+	if (fattrs) {
+		ret = usbg_f_uvc_set_frame_attrs(uvcf, format, frame_id, fattrs);
+		if (ret)
+			goto remove_frame;
+	}
+
+	frames[frame_id] = true;
+	return 0;
+
+remove_frame:
+	rmdir(frame_path);
+	return ret;
+}
+
+static int uvc_import_frame_attrs(struct usbg_f_uvc *uvcf, const char* format,
+				  int frame_id, config_setting_t *root)
+{
+	union usbg_f_uvc_frame_attr_val val;
+	int ret = 0;
+	int i;
+
+	for (i = USBG_F_UVC_FRAME_ATTR_MIN; i < USBG_F_UVC_FRAME_ATTR_MAX; ++i) {
+		ret = uvc_frame_attr[i].import(root, uvc_frame_attr[i].name, &val);
+		/* node not  found */
+		if (ret == 0)
+			continue;
+		/* error */
+		if (ret < 0)
+			break;
+
+		ret = usbg_f_uvc_set_frame_attr_val(uvcf, format, frame_id, i, val);
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+static int uvc_import_format_attrs(struct usbg_f_uvc *uvcf, const char* format,
+				    config_setting_t *root)
+{
+	union usbg_f_uvc_format_attr_val val;
+	int ret = 0;
+	int i;
+
+	for (i = USBG_F_UVC_FORMAT_ATTR_MIN; i < USBG_F_UVC_FORMAT_ATTR_MAX; ++i) {
+		if (uvc_format_attr[i].ro)
+			continue;
+
+		ret = uvc_format_attr[i].import(root, uvc_format_attr[i].name, &val);
+		/* node not  found */
+		if (ret == 0)
+			continue;
+		/* error */
+		if (ret < 0)
+			break;
+
+		ret = usbg_f_uvc_set_format_attr_val(uvcf, format, i, val);
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+static int uvc_import_format(struct usbg_f_uvc *uvcf, const char *format, bool *frames, config_setting_t *root)
+{
+	config_setting_t *frames_node, *node;
+	int i, nframes;
+	int ret = 0;
+
+	frames_node = config_setting_get_member(root, "frames");
+	if (!frames_node) {
+		ret = USBG_ERROR_INVALID_PARAM;
+		goto out;
+	}
+
+	if (!config_setting_is_list(frames_node)) {
+		ret = USBG_ERROR_INVALID_TYPE;
+		goto out;
+	}
+
+	nframes = config_setting_length(frames_node);
+	for (i = 0; i < nframes; ++i) {
+		node = config_setting_get_elem(frames_node, i);
+		if (!node) {
+			ret = USBG_ERROR_INVALID_FORMAT;
+			goto out;
+		}
+
+		if (!config_setting_is_group(node)) {
+			ret = USBG_ERROR_INVALID_TYPE;
+			goto out;
+		}
+		if (!frames[i]) {
+			ret = usbg_f_uvc_create_frame(uvcf, format, frames, i, NULL);
+			if (ret)
+				goto out;
+		}
+		ret = uvc_import_frame_attrs(uvcf, format, i, node);
+		if (ret)
+			goto out;
+	}
+
+out:
+	return ret;
+};
+
+static int uvc_import_config(struct usbg_f_uvc *uvcf, config_setting_t *root)
+{
+	union usbg_f_uvc_config_attr_val val;
+	config_setting_t *config_node;
+	int ret = 0;
+	int i;
+
+	config_node = config_setting_get_member(root, "config");
+	if (!config_node) {
+		ret = USBG_ERROR_INVALID_PARAM;
+		return ret;
+	}
+
+	if (!config_setting_is_group(config_node)) {
+		ret = USBG_ERROR_INVALID_TYPE;
+		return ret;
+	}
+
+	for (i = USBG_F_UVC_CONFIG_ATTR_MIN; i < USBG_F_UVC_CONFIG_ATTR_MAX; ++i) {
+		ret = uvc_config_attr[i].import(config_node, uvc_config_attr[i].name, &val);
+		/* node not  found */
+		if (ret == 0)
+			continue;
+		/* error */
+		if (ret < 0)
+			break;
+
+		ret = usbg_f_uvc_set_config_attr_val(uvcf, i, val);
+		if (ret)
+			break;
+	}
+
+	return ret;
+}
+
+static int uvc_libconfig_import(struct usbg_function *f, config_setting_t *root)
+{
+	struct usbg_f_uvc *uvcf = usbg_to_uvc_function(f);
+	config_setting_t *formats_node, *node;
+	int nmb, ret, i, nformats;
+	char fp[USBG_MAX_PATH_LENGTH];
+	const char *format;
+	struct formats *formats;
+
+	formats_node = config_setting_get_member(root, "formats");
+	if (!formats_node) {
+		ret = USBG_ERROR_INVALID_PARAM;
+		goto out;
+	}
+
+	if (!config_setting_is_group(formats_node)) {
+		ret = USBG_ERROR_INVALID_TYPE;
+		goto out;
+	}
+
+	nformats = config_setting_length(formats_node);
+	formats = get_formats_mask(uvcf);
+	for (i = 0; i < nformats; ++i) {
+		node = config_setting_get_elem(formats_node, i);
+		if (!node) {
+			ret = USBG_ERROR_INVALID_FORMAT;
+			goto out;
+		}
+
+		if (!config_setting_is_group(node)) {
+			ret = USBG_ERROR_INVALID_TYPE;
+			goto out;
+		}
+
+		format = config_setting_name(node);
+
+		nmb = snprintf(fp, sizeof(fp), "%s/%c", format, format[0]);
+		if (nmb >= sizeof(fp))
+			return USBG_ERROR_PATH_TOO_LONG;
+
+		ret = uvc_import_format(uvcf, fp, formats[i].frames, node);
+		if (ret)
+			goto out;
+
+		ret = uvc_import_format_attrs(uvcf, fp, node);
+		if (ret)
+			goto out;
+	}
+
+	ret = uvc_import_config(uvcf, root);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	ret = uvc_set_class(uvcf, UVC_PATH_CONTROL);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+	ret = uvc_set_class(uvcf, UVC_PATH_STREAMING);
+	if (ret != USBG_SUCCESS)
+		return ret;
+
+out:
+	return ret;
+
+}
+
+static int uvc_export_config(struct usbg_f_uvc *uvcf, config_setting_t *root)
+{
+	config_setting_t *config_node;
+	union usbg_f_uvc_config_attr_val val;
+	int i;
+	int ret = 0;
+
+	config_node = config_setting_add(root, "config", CONFIG_TYPE_GROUP);
+	if (!config_node)
+		goto out;
+
+	for (i = USBG_F_UVC_CONFIG_ATTR_MIN; i < USBG_F_UVC_CONFIG_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_get_config_attr_val(uvcf, i, &val);
+		if (ret)
+			break;
+
+		ret = uvc_config_attr[i].export(config_node, uvc_config_attr[i].name, &val);
+		if (ret)
+			break;
+	}
+
+out:
+	return ret;
+};
+
+static int uvc_export_format_attrs(struct usbg_f_uvc *uvcf, const char *format,
+				  config_setting_t *root)
+{
+	union usbg_f_uvc_format_attr_val val;
+	int ret = 0;
+	int i;
+
+	for (i = USBG_F_UVC_FORMAT_ATTR_MIN; i < USBG_F_UVC_FORMAT_ATTR_MAX; ++i) {
+		ret = usbg_f_uvc_get_format_attr_val(uvcf, format, i, &val);
+		if (ret)
+			break;
+
+		ret = uvc_format_attr[i].export(root, uvc_format_attr[i].name, &val);
+		if (ret)