libusbgx: Use suitable prefix for usbg_function_type enum

Let's use USBG_ prefix for usbg_function_type enum values
to avoid users confusion.

Signed-off-by: Krzysztof Opasiak <k.opasiak@samsung.com>

9 files changed, 116 insertions, 116 deletions

diff --git a/examples/gadget-acm-ecm.c b/examples/gadget-acm-ecm.c
index fe0b1ef..b73135f 100644
--- a/examples/gadget-acm-ecm.c
+++ b/examples/gadget-acm-ecm.c
@@ -78,7 +78,7 @@ int main(void)
 		goto out2;
 	}
 
-	usbg_ret = usbg_create_function(g, F_ACM, "usb0", NULL, &f_acm0);
+	usbg_ret = usbg_create_function(g, USBG_F_ACM, "usb0", NULL, &f_acm0);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating acm0 function\n");
 		fprintf(stderr, "Error: %s : %s\n", usbg_error_name(usbg_ret),
@@ -86,7 +86,7 @@ int main(void)
 		goto out2;
 	}
 
-	usbg_ret = usbg_create_function(g, F_ACM, "usb1", NULL, &f_acm1);
+	usbg_ret = usbg_create_function(g, USBG_F_ACM, "usb1", NULL, &f_acm1);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating acm1 function\n");
 		fprintf(stderr, "Error: %s : %s\n", usbg_error_name(usbg_ret),
@@ -94,7 +94,7 @@ int main(void)
 		goto out2;
 	}
 
-	usbg_ret = usbg_create_function(g, F_ECM, "usb0", NULL, &f_ecm);
+	usbg_ret = usbg_create_function(g, USBG_F_ECM, "usb0", NULL, &f_ecm);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating ecm function\n");
 		fprintf(stderr, "Error: %s : %s\n", usbg_error_name(usbg_ret),
diff --git a/examples/gadget-ffs.c b/examples/gadget-ffs.c
index b95f13b..6ba10c6 100644
--- a/examples/gadget-ffs.c
+++ b/examples/gadget-ffs.c
@@ -79,7 +79,7 @@ int main(void)
 		goto out2;
 	}
 
-	usbg_ret = usbg_create_function(g, F_FFS, "my_dev_name", NULL, &f_ffs1);
+	usbg_ret = usbg_create_function(g, USBG_F_FFS, "my_dev_name", NULL, &f_ffs1);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating ffs1 function\n");
 		fprintf(stderr, "Error: %s : %s\n", usbg_error_name(usbg_ret),
@@ -87,7 +87,7 @@ int main(void)
 		goto out2;
 	}
 
-	usbg_ret = usbg_create_function(g, F_FFS, "my_other_dev_name",
+	usbg_ret = usbg_create_function(g, USBG_F_FFS, "my_other_dev_name",
 					NULL, &f_ffs2);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating ffs2 function\n");
diff --git a/examples/gadget-midi.c b/examples/gadget-midi.c
index 61556cc..2d56c0d 100644
--- a/examples/gadget-midi.c
+++ b/examples/gadget-midi.c
@@ -76,7 +76,7 @@ int main() {
 				usbg_strerror(usbg_ret));
 		goto out2;
 	}
-	usbg_ret = usbg_create_function(g, F_MIDI, "usb0", &f_attrs, &f_midi);
+	usbg_ret = usbg_create_function(g, USBG_F_MIDI, "usb0", &f_attrs, &f_midi);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating function\n");
 		fprintf(stderr, "Error: %s : %s\n", usbg_error_name(usbg_ret),
diff --git a/examples/gadget-ms.c b/examples/gadget-ms.c
index 017a6d1..36b0847 100644
--- a/examples/gadget-ms.c
+++ b/examples/gadget-ms.c
@@ -115,7 +115,7 @@ int main(int argc, char **argv)
 		goto out2;
 	}
 
-	usbg_ret = usbg_create_function(g, F_MASS_STORAGE, "my_reader",
+	usbg_ret = usbg_create_function(g, USBG_F_MASS_STORAGE, "my_reader",
 					&f_attrs, &f_ms);
 	if (usbg_ret != USBG_SUCCESS) {
 		fprintf(stderr, "Error creating mass storage function\n");
diff --git a/examples/show-gadgets.c b/examples/show-gadgets.c
index 403693e..dcac7d5 100644
--- a/examples/show-gadgets.c
+++ b/examples/show-gadgets.c
@@ -128,18 +128,18 @@ void show_function(usbg_function *f)
 			usbg_get_function_type_str(type), instance);
 
 	switch (type) {
-	case F_ACM:
-	case F_OBEX:
-	case F_SERIAL:
+	case USBG_F_ACM:
+	case USBG_F_OBEX:
+	case USBG_F_SERIAL:
 		fprintf(stdout, "    port_num\t\t%d\n",
 				f_attrs.serial_port_num);
 		break;
 
-	case F_ECM:
-	case F_SUBSET:
-	case F_NCM:
-	case F_EEM:
-	case F_RNDIS:
+	case USBG_F_ECM:
+	case USBG_F_SUBSET:
+	case USBG_F_NCM:
+	case USBG_F_EEM:
+	case USBG_F_RNDIS:
 	{
 		struct usbg_f_net_attrs *f_net_attrs = &f_attrs.net;
 
@@ -152,15 +152,15 @@ void show_function(usbg_function *f)
 		break;
 	}
 
-	case F_PHONET:
+	case USBG_F_PHONET:
 		fprintf(stdout, "    ifname\t\t%s\n", f_attrs.phonet_ifname);
 		break;
 
-	case F_FFS:
+	case USBG_F_FFS:
 		fprintf(stdout, "    dev_name\t\t%s\n", f_attrs.ffs_dev_name);
 		break;
 
-	case F_MASS_STORAGE:
+	case USBG_F_MASS_STORAGE:
 	{
 		struct usbg_f_ms_attrs *attrs = &f_attrs.ms;
 		int i;
@@ -178,7 +178,7 @@ void show_function(usbg_function *f)
 		break;
 	}
 
-	case F_MIDI:
+	case USBG_F_MIDI:
 	{
 		struct usbg_f_midi_attrs *attrs = &f_attrs.midi;
 
diff --git a/include/usbg/usbg.h b/include/usbg/usbg.h
index 359192a..8a3578d 100644
--- a/include/usbg/usbg.h
+++ b/include/usbg/usbg.h
@@ -180,19 +180,19 @@ typedef struct
 typedef enum
 {
 	USBG_FUNCTION_TYPE_MIN = 0,
-	F_SERIAL = USBG_FUNCTION_TYPE_MIN,
-	F_ACM,
-	F_OBEX,
-	F_ECM,
-	F_SUBSET,
-	F_NCM,
-	F_EEM,
-	F_RNDIS,
-	F_PHONET,
-	F_FFS,
-	F_MASS_STORAGE,
-	F_MIDI,
-	F_LOOPBACK,
+	USBG_F_SERIAL = USBG_FUNCTION_TYPE_MIN,
+	USBG_F_ACM,
+	USBG_F_OBEX,
+	USBG_F_ECM,
+	USBG_F_SUBSET,
+	USBG_F_NCM,
+	USBG_F_EEM,
+	USBG_F_RNDIS,
+	USBG_F_PHONET,
+	USBG_F_FFS,
+	USBG_F_MASS_STORAGE,
+	USBG_F_MIDI,
+	USBG_F_LOOPBACK,
 	USBG_FUNCTION_TYPE_MAX,
 } usbg_function_type;
 
diff --git a/src/usbg.c b/src/usbg.c
index ef3ec9f..f323158 100644
--- a/src/usbg.c
+++ b/src/usbg.c
@@ -56,19 +56,19 @@ extern struct usbg_function_type usbg_f_type_loopback;
  * @brief Types of functions supported by library
  */
 struct usbg_function_type* function_types[] = {
-	[F_ACM] = &usbg_f_type_acm,
-	[F_SERIAL] = &usbg_f_type_serial,
-	[F_OBEX] = &usbg_f_type_obex,
-	[F_ECM] = &usbg_f_type_ecm,
-	[F_SUBSET] = &usbg_f_type_subset,
-	[F_NCM] = &usbg_f_type_ncm,
-	[F_EEM] = &usbg_f_type_eem,
-	[F_RNDIS] = &usbg_f_type_rndis,
-	[F_FFS] = &usbg_f_type_ffs,
-	[F_MIDI] = &usbg_f_type_midi,
-	[F_MASS_STORAGE] = &usbg_f_type_ms,
-	[F_PHONET] = &usbg_f_type_phonet,
-	[F_LOOPBACK] = &usbg_f_type_loopback,
+	[USBG_F_ACM] = &usbg_f_type_acm,
+	[USBG_F_SERIAL] = &usbg_f_type_serial,
+	[USBG_F_OBEX] = &usbg_f_type_obex,
+	[USBG_F_ECM] = &usbg_f_type_ecm,
+	[USBG_F_SUBSET] = &usbg_f_type_subset,
+	[USBG_F_NCM] = &usbg_f_type_ncm,
+	[USBG_F_EEM] = &usbg_f_type_eem,
+	[USBG_F_RNDIS] = &usbg_f_type_rndis,
+	[USBG_F_FFS] = &usbg_f_type_ffs,
+	[USBG_F_MIDI] = &usbg_f_type_midi,
+	[USBG_F_MASS_STORAGE] = &usbg_f_type_ms,
+	[USBG_F_PHONET] = &usbg_f_type_phonet,
+	[USBG_F_LOOPBACK] = &usbg_f_type_loopback,
 };
 
 ARRAY_SIZE_SENTINEL(function_types, USBG_FUNCTION_TYPE_MAX);
diff --git a/tests/test.c b/tests/test.c
index a4d7fc7..865aa0a 100644
--- a/tests/test.c
+++ b/tests/test.c
@@ -107,8 +107,8 @@ static char *long_udcs[] = {
  * @details Used to go through init when testing other things
  */
 static struct test_function simple_funcs[] = {
-	FUNC_FROM_TYPE(F_ECM),
-	FUNC_FROM_TYPE(F_ACM),
+	FUNC_FROM_TYPE(USBG_F_ECM),
+	FUNC_FROM_TYPE(USBG_F_ACM),
 	TEST_FUNCTION_LIST_END
 };
 
@@ -118,23 +118,23 @@ static struct test_function simple_funcs[] = {
  * processed correctly
  */
 static struct test_function all_funcs[] = {
-	FUNC_FROM_TYPE(F_SERIAL),
-	FUNC_FROM_TYPE(F_ACM),
-	FUNC_FROM_TYPE(F_OBEX),
-	FUNC_FROM_TYPE(F_ECM),
-	FUNC_FROM_TYPE(F_SUBSET),
-	FUNC_FROM_TYPE(F_NCM),
-	FUNC_FROM_TYPE(F_EEM),
-	FUNC_FROM_TYPE(F_RNDIS),
-	FUNC_FROM_TYPE(F_PHONET),
-	FUNC_FROM_TYPE(F_FFS),
+	FUNC_FROM_TYPE(USBG_F_SERIAL),
+	FUNC_FROM_TYPE(USBG_F_ACM),
+	FUNC_FROM_TYPE(USBG_F_OBEX),
+	FUNC_FROM_TYPE(USBG_F_ECM),
+	FUNC_FROM_TYPE(USBG_F_SUBSET),
+	FUNC_FROM_TYPE(USBG_F_NCM),
+	FUNC_FROM_TYPE(USBG_F_EEM),
+	FUNC_FROM_TYPE(USBG_F_RNDIS),
+	FUNC_FROM_TYPE(USBG_F_PHONET),
+	FUNC_FROM_TYPE(USBG_F_FFS),
 	TEST_FUNCTION_LIST_END
 };
 
 static struct test_function same_type_funcs[] = {
-	FUNC_FROM_TYPE(F_SERIAL),
-	FUNC_FROM_TYPE(F_SERIAL),
-	FUNC_FROM_TYPE(F_SERIAL),
+	FUNC_FROM_TYPE(USBG_F_SERIAL),
+	FUNC_FROM_TYPE(USBG_F_SERIAL),
+	FUNC_FROM_TYPE(USBG_F_SERIAL),
 	TEST_FUNCTION_LIST_END
 };
 
@@ -460,121 +460,121 @@ static void *setup_f_attrs(int f_type, void *attrs)
 
 static int setup_f_serial_attrs(void **state)
 {
-	*state = setup_f_attrs(F_SERIAL, &simple_serial_attrs);
+	*state = setup_f_attrs(USBG_F_SERIAL, &simple_serial_attrs);
 	return 0;
 }
 
 static int setup_f_serial_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_SERIAL, &writable_serial_attrs);
+	*state = setup_f_attrs(USBG_F_SERIAL, &writable_serial_attrs);
 	return 0;
 }
 
 static int setup_f_acm_attrs(void **state)
 {
-	*state = setup_f_attrs(F_ACM, &simple_serial_attrs);
+	*state = setup_f_attrs(USBG_F_ACM, &simple_serial_attrs);
 	return 0;
 }
 
 static int setup_f_acm_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_ACM, &writable_serial_attrs);
+	*state = setup_f_attrs(USBG_F_ACM, &writable_serial_attrs);
 	return 0;
 }
 
 static int setup_f_obex_attrs(void **state)
 {
-	*state = setup_f_attrs(F_OBEX, &simple_serial_attrs);
+	*state = setup_f_attrs(USBG_F_OBEX, &simple_serial_attrs);
 	return 0;
 }
 
 static int setup_f_obex_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_OBEX, &writable_serial_attrs);
+	*state = setup_f_attrs(USBG_F_OBEX, &writable_serial_attrs);
 	return 0;
 }
 
 static int setup_f_ecm_attrs(void **state)
 {
-	*state = setup_f_attrs(F_ECM, &simple_net_attrs);
+	*state = setup_f_attrs(USBG_F_ECM, &simple_net_attrs);
 	return 0;
 }
 
 static int setup_f_ecm_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_ECM, &writable_net_attrs);
+	*state = setup_f_attrs(USBG_F_ECM, &writable_net_attrs);
 	return 0;
 }
 
 static int setup_f_subset_attrs(void **state)
 {
-	*state = setup_f_attrs(F_SUBSET, &simple_net_attrs);
+	*state = setup_f_attrs(USBG_F_SUBSET, &simple_net_attrs);
 	return 0;
 }
 
 static int setup_f_subset_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_SUBSET, &writable_net_attrs);
+	*state = setup_f_attrs(USBG_F_SUBSET, &writable_net_attrs);
 	return 0;
 }
 
 static int setup_f_ncm_attrs(void **state)
 {
-	*state = setup_f_attrs(F_NCM, &simple_net_attrs);
+	*state = setup_f_attrs(USBG_F_NCM, &simple_net_attrs);
 	return 0;
 }
 
 static int setup_f_ncm_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_NCM, &writable_net_attrs);
+	*state = setup_f_attrs(USBG_F_NCM, &writable_net_attrs);
 	return 0;
 }
 
 static int setup_f_eem_attrs(void **state)
 {
-	*state = setup_f_attrs(F_EEM, &simple_net_attrs);
+	*state = setup_f_attrs(USBG_F_EEM, &simple_net_attrs);
 	return 0;
 }
 
 static int setup_f_eem_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_EEM, &writable_net_attrs);
+	*state = setup_f_attrs(USBG_F_EEM, &writable_net_attrs);
 	return 0;
 }
 
 static int setup_f_rndis_attrs(void **state)
 {
-	*state = setup_f_attrs(F_RNDIS, &simple_net_attrs);
+	*state = setup_f_attrs(USBG_F_RNDIS, &simple_net_attrs);
 	return 0;
 }
 
 static int setup_f_rndis_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_RNDIS, &writable_net_attrs);
+	*state = setup_f_attrs(USBG_F_RNDIS, &writable_net_attrs);
 	return 0;
 }
 
 static int setup_f_phonet_attrs(void **state)
 {
-	*state = setup_f_attrs(F_PHONET, &simple_phonet_attrs);
+	*state = setup_f_attrs(USBG_F_PHONET, &simple_phonet_attrs);
 	return 0;
 }
 
 static int setup_f_phonet_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_PHONET, &writable_phonet_attrs);
+	*state = setup_f_attrs(USBG_F_PHONET, &writable_phonet_attrs);
 	return 0;
 }
 
 static int setup_f_ffs_attrs(void **state)
 {
-	*state = setup_f_attrs(F_FFS, &simple_ffs_attrs);
+	*state = setup_f_attrs(USBG_F_FFS, &simple_ffs_attrs);
 	return 0;
 }
 
 static int setup_f_ffs_writable_attrs(void **state)
 {
-	*state = setup_f_attrs(F_FFS, &writable_ffs_attrs);
+	*state = setup_f_attrs(USBG_F_FFS, &writable_ffs_attrs);
 	return 0;
 }
 
@@ -792,7 +792,7 @@ static void test_get_function_fail(void **state)
 	g = usbg_get_first_gadget(s);
 	assert_non_null(g);
 
-	f = usbg_get_function(g, F_ACM, "non-existing-instance");
+	f = usbg_get_function(g, USBG_F_ACM, "non-existing-instance");
 	assert_null(f);
 
 	f = usbg_get_function(g, 9001, "0");
@@ -811,16 +811,16 @@ static void test_get_function_type_str(void **state)
 		usbg_function_type type;
 		const char *str;
 	} types[] = {
-		{F_SERIAL, "gser"},
-		{F_ACM, "acm"},
-		{F_OBEX, "obex"},
-		{F_ECM, "ecm"},
-		{F_SUBSET, "geth"},
-		{F_NCM, "ncm"},
-		{F_EEM, "eem"},
-		{F_RNDIS, "rndis"},
-		{F_PHONET, "phonet"},
-		{F_FFS, "ffs"},
+		{USBG_F_SERIAL, "gser"},
+		{USBG_F_ACM, "acm"},
+		{USBG_F_OBEX, "obex"},
+		{USBG_F_ECM, "ecm"},
+		{USBG_F_SUBSET, "geth"},
+		{USBG_F_NCM, "ncm"},
+		{USBG_F_EEM, "eem"},
+		{USBG_F_RNDIS, "rndis"},
+		{USBG_F_PHONET, "phonet"},
+		{USBG_F_FFS, "ffs"},
 	};
 
 	const char *str;
diff --git a/tests/usbg-test.c b/tests/usbg-test.c
index da6648b..078ed96 100644
--- a/tests/usbg-test.c
+++ b/tests/usbg-test.c
@@ -1064,22 +1064,22 @@ static void push_phonet_attrs(struct test_function *func,
 void push_function_attrs(struct test_function *func, void *function_attrs)
 {
 	switch (func->type) {
-	case F_ACM:
-	case F_OBEX:
-	case F_SERIAL:
+	case USBG_F_ACM:
+	case USBG_F_OBEX:
+	case USBG_F_SERIAL:
 		push_serial_attrs(func, function_attrs);
 		break;
-	case F_ECM:
-	case F_SUBSET:
-	case F_NCM:
-	case F_EEM:
-	case F_RNDIS:
+	case USBG_F_ECM:
+	case USBG_F_SUBSET:
+	case USBG_F_NCM:
+	case USBG_F_EEM:
+	case USBG_F_RNDIS:
 		push_net_attrs(func, function_attrs);
 		break;
-	case F_PHONET:
+	case USBG_F_PHONET:
 		push_phonet_attrs(func, function_attrs);
 		break;
-	case F_FFS:
+	case USBG_F_FFS:
 		// ffs does not exist in filesystem
 	default:
 		break;
@@ -1114,11 +1114,11 @@ static void pull_function_net_attrs(struct test_function *func,
 void pull_function_attrs(struct test_function *func, void *attrs)
 {
 	switch (func->type) {
-	case F_ECM:
-	case F_SUBSET:
-	case F_NCM:
-	case F_EEM:
-	case F_RNDIS:
+	case USBG_F_ECM:
+	case USBG_F_SUBSET:
+	case USBG_F_NCM:
+	case USBG_F_EEM:
+	case USBG_F_RNDIS:
 		pull_function_net_attrs(func, attrs);
 		break;
 	default:
@@ -1307,22 +1307,22 @@ void assert_function_attrs_equal(void *actual, void *expected,
 				 usbg_function_type type)
 {
 	switch (type) {
-	case F_ACM:
-	case F_OBEX:
-	case F_SERIAL:
+	case USBG_F_ACM:
+	case USBG_F_OBEX:
+	case USBG_F_SERIAL:
 		assert_f_serial_attrs_equal(actual, expected);
 		break;
-	case F_ECM:
-	case F_SUBSET:
-	case F_NCM:
-	case F_EEM:
-	case F_RNDIS:
+	case USBG_F_ECM:
+	case USBG_F_SUBSET:
+	case USBG_F_NCM:
+	case USBG_F_EEM:
+	case USBG_F_RNDIS:
 		assert_f_net_attrs_equal(actual, expected);
 		break;
-	case F_PHONET:
+	case USBG_F_PHONET:
 		assert_f_phonet_attrs_equal(actual, expected);
 		break;
-	case F_FFS:
+	case USBG_F_FFS:
 		assert_f_ffs_attrs_equal(actual, expected);
 		break;
 	default: