linux-kernel.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
* [PATCH v4 0/3] USB Audio Gadget refactoring
@ 2017-05-17 22:37 Ruslan Bilovol
  2017-05-17 22:37 ` [PATCH v4 1/3] usb: gadget: f_uac2: remove platform driver/device creation Ruslan Bilovol
                   ` (3 more replies)
  0 siblings, 4 replies; 17+ messages in thread
From: Ruslan Bilovol @ 2017-05-17 22:37 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

I came to this patch series when wanted to do two things:
 - use UAC1 as virtual ALSA sound card on gadget side,
   just like UAC2 is used so it's possible to do rate
   resampling
 - have both playback/capture support in UAC1

Since I wanted to have same behavior for both UAC1/UAC2,
obviously I've got an utility part (u_audio.c) for
virtual ALSA sound card handling like we have
for ethernet(u_ether) or serial(u_serial) functions.
Function-specific parts (f_uac1/f_uac2) became almost 
as storage for class-specific USB descriptors, some
boilerplate for configfs, binding and few USB
config request handling.

Originally in RFC [1] I've posted before, there was
major change to f_uac1 after that it couldn't do
direct play to existing ALSA sound card anymore,
representing audio on gadget side as virtual
ALSA sound card where audio streams are simply
sinked to and sourced from it, so it may break
current usecase for some people (and that's why
it was RFC).

During RFC discussion, it was agreed to not touch
existing f_uac1 implementation and create new one
instead. This patchset (v4) introduced new function
named f_uac1_acard and doesn't touch current f_uac1
implementation, so people still can use old behavior

Now, it's possible to use existing user-space
applications for audio routing between Audio Gadget
and real sound card. I personally use alsaloop tool
from alsautils and have ability to create PCM
loopback between two different ALSA cards using
rate resampling, which was not possible with previous
"direct play to ALSA card" approach in f_uac1. 

While here, also dropped redundant platform
driver/device creation in f_uac2 driver (as well as
didn't add "never implemented" volume/mute functionality
in f_uac1 to f_uac1_acard) that made this work even
easier to do.

This series is tested with both legacy g_audio.ko and
modern configfs approaches under Ubuntu 14.04 (UAC1 and
UAC2) and under Windows7 x64 (UAC1 only) having
perfect results in all cases.

Comments, testing are welcome.

v4 changes:
 - renamed f_uac1_newapi to f_uac1_acard that is
   more meaningful
 - rebased on top of balbi/next

v3 changes:
 - renamed u_audio exported symbols so they don't
   conflict with old f_uac1 if both are built-in.

v2 changes:
 - do not touch f_uac1, instead created f_uac1_newapi
 - added documentation for f_uac1_newapi
 - rebased on top of v4.8-rc1

[1] https://lkml.org/lkml/2016/5/23/649

Ruslan Bilovol (3):
  usb: gadget: f_uac2: remove platform driver/device creation
  usb: gadget: f_uac2: split out audio core
  usb: gadget: add f_uac1 variant based on a new u_audio api

 .../ABI/testing/configfs-usb-gadget-uac1_acard     |  14 +
 Documentation/usb/gadget-testing.txt               |  45 ++
 drivers/usb/gadget/Kconfig                         |  25 +
 drivers/usb/gadget/function/Makefile               |   3 +
 drivers/usb/gadget/function/f_uac1_acard.c         | 803 +++++++++++++++++++++
 drivers/usb/gadget/function/f_uac2.c               | 798 +++-----------------
 drivers/usb/gadget/function/u_audio.c              | 661 +++++++++++++++++
 drivers/usb/gadget/function/u_audio.h              |  95 +++
 drivers/usb/gadget/function/u_uac1_acard.h         |  41 ++
 drivers/usb/gadget/legacy/Kconfig                  |  14 +-
 drivers/usb/gadget/legacy/audio.c                  |  53 ++
 11 files changed, 1850 insertions(+), 702 deletions(-)
 create mode 100644 Documentation/ABI/testing/configfs-usb-gadget-uac1_acard
 create mode 100644 drivers/usb/gadget/function/f_uac1_acard.c
 create mode 100644 drivers/usb/gadget/function/u_audio.c
 create mode 100644 drivers/usb/gadget/function/u_audio.h
 create mode 100644 drivers/usb/gadget/function/u_uac1_acard.h

-- 
1.9.1

^ permalink raw reply	[flat|nested] 17+ messages in thread

* [PATCH v4 1/3] usb: gadget: f_uac2: remove platform driver/device creation
  2017-05-17 22:37 [PATCH v4 0/3] USB Audio Gadget refactoring Ruslan Bilovol
@ 2017-05-17 22:37 ` Ruslan Bilovol
  2017-05-17 22:37 ` [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core Ruslan Bilovol
                   ` (2 subsequent siblings)
  3 siblings, 0 replies; 17+ messages in thread
From: Ruslan Bilovol @ 2017-05-17 22:37 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

Simplify f_uac2 by removing platform driver/device
creation; use composite's usb_gadget device as
parent for sound card and for debug prints.
This removes extra layer of code without any functional
change.

Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
---
 drivers/usb/gadget/function/f_uac2.c | 107 +++++++++--------------------------
 1 file changed, 28 insertions(+), 79 deletions(-)

diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c
index f6a0d3a..d4565b5 100644
--- a/drivers/usb/gadget/function/f_uac2.c
+++ b/drivers/usb/gadget/function/f_uac2.c
@@ -13,7 +13,6 @@
 
 #include <linux/usb/audio.h>
 #include <linux/usb/audio-v2.h>
-#include <linux/platform_device.h>
 #include <linux/module.h>
 
 #include <sound/core.h>
@@ -51,8 +50,6 @@
 #define UNFLW_CTRL	8
 #define OVFLW_CTRL	10
 
-static const char *uac2_name = "snd_uac2";
-
 struct uac2_req {
 	struct uac2_rtd_params *pp; /* parent param */
 	struct usb_request *req;
@@ -81,9 +78,6 @@ struct uac2_rtd_params {
 };
 
 struct snd_uac2_chip {
-	struct platform_device pdev;
-	struct platform_driver pdrv;
-
 	struct uac2_rtd_params p_prm;
 	struct uac2_rtd_params c_prm;
 
@@ -122,6 +116,7 @@ struct audio_dev {
 
 	struct usb_ep *in_ep, *out_ep;
 	struct usb_function func;
+	struct usb_gadget *gadget;
 
 	/* The ALSA Sound Card it represents on the USB-Client side */
 	struct snd_uac2_chip uac2;
@@ -140,12 +135,6 @@ struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
 }
 
 static inline
-struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p)
-{
-	return container_of(p, struct snd_uac2_chip, pdev);
-}
-
-static inline
 struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
 {
 	return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
@@ -254,7 +243,7 @@ uint num_channels(uint chanmask)
 
 exit:
 	if (usb_ep_queue(ep, req, GFP_ATOMIC))
-		dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
+		dev_err(uac2->card->dev, "%d Error!\n", __LINE__);
 
 	if (update_alsa)
 		snd_pcm_period_elapsed(substream);
@@ -440,23 +429,22 @@ static int uac2_pcm_null(struct snd_pcm_substream *substream)
 	.prepare = uac2_pcm_null,
 };
 
-static int snd_uac2_probe(struct platform_device *pdev)
+static int snd_uac2_probe(struct audio_dev *audio_dev)
 {
-	struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
+	struct snd_uac2_chip *uac2 = &audio_dev->uac2;
 	struct snd_card *card;
 	struct snd_pcm *pcm;
-	struct audio_dev *audio_dev;
 	struct f_uac2_opts *opts;
 	int err;
 	int p_chmask, c_chmask;
 
-	audio_dev = uac2_to_agdev(uac2);
 	opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
 	p_chmask = opts->p_chmask;
 	c_chmask = opts->c_chmask;
 
 	/* Choose any slot, with no id */
-	err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card);
+	err = snd_card_new(&audio_dev->gadget->dev,
+			-1, NULL, THIS_MODULE, 0, &card);
 	if (err < 0)
 		return err;
 
@@ -481,16 +469,15 @@ static int snd_uac2_probe(struct platform_device *pdev)
 
 	strcpy(card->driver, "UAC2_Gadget");
 	strcpy(card->shortname, "UAC2_Gadget");
-	sprintf(card->longname, "UAC2_Gadget %i", pdev->id);
+	sprintf(card->longname, "UAC2_Gadget %i", card->dev->id);
 
 	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
 		snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
 
 	err = snd_card_register(card);
-	if (!err) {
-		platform_set_drvdata(pdev, card);
+
+	if (!err)
 		return 0;
-	}
 
 snd_fail:
 	snd_card_free(card);
@@ -501,9 +488,9 @@ static int snd_uac2_probe(struct platform_device *pdev)
 	return err;
 }
 
-static int snd_uac2_remove(struct platform_device *pdev)
+static int snd_uac2_remove(struct audio_dev *audio_dev)
 {
-	struct snd_card *card = platform_get_drvdata(pdev);
+	struct snd_card *card = audio_dev->uac2.card;
 
 	if (card)
 		return snd_card_free(card);
@@ -511,45 +498,6 @@ static int snd_uac2_remove(struct platform_device *pdev)
 	return 0;
 }
 
-static void snd_uac2_release(struct device *dev)
-{
-	dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
-}
-
-static int alsa_uac2_init(struct audio_dev *agdev)
-{
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
-	int err;
-
-	uac2->pdrv.probe = snd_uac2_probe;
-	uac2->pdrv.remove = snd_uac2_remove;
-	uac2->pdrv.driver.name = uac2_name;
-
-	uac2->pdev.id = 0;
-	uac2->pdev.name = uac2_name;
-	uac2->pdev.dev.release = snd_uac2_release;
-
-	/* Register snd_uac2 driver */
-	err = platform_driver_register(&uac2->pdrv);
-	if (err)
-		return err;
-
-	/* Register snd_uac2 device */
-	err = platform_device_register(&uac2->pdev);
-	if (err)
-		platform_driver_unregister(&uac2->pdrv);
-
-	return err;
-}
-
-static void alsa_uac2_exit(struct audio_dev *agdev)
-{
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
-
-	platform_driver_unregister(&uac2->pdrv);
-	platform_device_unregister(&uac2->pdev);
-}
-
 
 /* --------- USB Function Interface ------------- */
 
@@ -960,7 +908,7 @@ struct cntrl_range_lay3 {
 	}
 
 	if (usb_ep_disable(ep))
-		dev_err(&uac2->pdev.dev,
+		dev_err(uac2->card->dev,
 			"%s:%d Error!\n", __func__, __LINE__);
 }
 
@@ -994,7 +942,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	struct snd_uac2_chip *uac2 = &agdev->uac2;
 	struct usb_composite_dev *cdev = cfg->cdev;
 	struct usb_gadget *gadget = cdev->gadget;
-	struct device *dev = &uac2->pdev.dev;
+	struct device *dev = &gadget->dev;
 	struct uac2_rtd_params *prm;
 	struct f_uac2_opts *uac2_opts;
 	struct usb_string *us;
@@ -1094,6 +1042,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	if (ret)
 		return ret;
 
+	agdev->gadget = gadget;
+
 	prm = &agdev->uac2.c_prm;
 	prm->max_psize = hs_epout_desc.wMaxPacketSize;
 	prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
@@ -1124,7 +1074,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		goto err_no_memory;
 	}
 
-	ret = alsa_uac2_init(agdev);
+	ret = snd_uac2_probe(agdev);
 	if (ret)
 		goto err_no_memory;
 	return 0;
@@ -1136,6 +1086,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	kfree(agdev->uac2.c_prm.rbuf);
 err_free_descs:
 	usb_free_all_descriptors(fn);
+	agdev->gadget = NULL;
 	return ret;
 }
 
@@ -1147,7 +1098,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
 	struct snd_uac2_chip *uac2 = &agdev->uac2;
 	struct usb_gadget *gadget = cdev->gadget;
-	struct device *dev = &uac2->pdev.dev;
+	struct device *dev = &gadget->dev;
 	struct usb_request *req;
 	struct usb_ep *ep;
 	struct uac2_rtd_params *prm;
@@ -1247,7 +1198,6 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 afunc_get_alt(struct usb_function *fn, unsigned intf)
 {
 	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
 
 	if (intf == agdev->ac_intf)
 		return agdev->ac_alt;
@@ -1256,7 +1206,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	else if (intf == agdev->as_in_intf)
 		return agdev->as_in_alt;
 	else
-		dev_err(&uac2->pdev.dev,
+		dev_err(&agdev->gadget->dev,
 			"%s:%d Invalid Interface %d!\n",
 			__func__, __LINE__, intf);
 
@@ -1281,7 +1231,6 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 {
 	struct usb_request *req = fn->config->cdev->req;
 	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
 	struct f_uac2_opts *opts;
 	u16 w_length = le16_to_cpu(cr->wLength);
 	u16 w_index = le16_to_cpu(cr->wIndex);
@@ -1310,7 +1259,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		*(u8 *)req->buf = 1;
 		value = min_t(unsigned, w_length, 1);
 	} else {
-		dev_err(&uac2->pdev.dev,
+		dev_err(&agdev->gadget->dev,
 			"%s:%d control_selector=%d TODO!\n",
 			__func__, __LINE__, control_selector);
 	}
@@ -1323,7 +1272,6 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 {
 	struct usb_request *req = fn->config->cdev->req;
 	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
 	struct f_uac2_opts *opts;
 	u16 w_length = le16_to_cpu(cr->wLength);
 	u16 w_index = le16_to_cpu(cr->wIndex);
@@ -1353,7 +1301,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		value = min_t(unsigned, w_length, sizeof r);
 		memcpy(req->buf, &r, value);
 	} else {
-		dev_err(&uac2->pdev.dev,
+		dev_err(&agdev->gadget->dev,
 			"%s:%d control_selector=%d TODO!\n",
 			__func__, __LINE__, control_selector);
 	}
@@ -1389,12 +1337,11 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 {
 	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
 	u16 w_index = le16_to_cpu(cr->wIndex);
 	u8 intf = w_index & 0xff;
 
 	if (intf != agdev->ac_intf) {
-		dev_err(&uac2->pdev.dev,
+		dev_err(&agdev->gadget->dev,
 			"%s:%d Error!\n", __func__, __LINE__);
 		return -EOPNOTSUPP;
 	}
@@ -1412,7 +1359,6 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 {
 	struct usb_composite_dev *cdev = fn->config->cdev;
 	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
 	struct usb_request *req = cdev->req;
 	u16 w_length = le16_to_cpu(cr->wLength);
 	int value = -EOPNOTSUPP;
@@ -1424,14 +1370,15 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
 		value = setup_rq_inf(fn, cr);
 	else
-		dev_err(&uac2->pdev.dev, "%s:%d Error!\n", __func__, __LINE__);
+		dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
+				__func__, __LINE__);
 
 	if (value >= 0) {
 		req->length = value;
 		req->zero = value < w_length;
 		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 		if (value < 0) {
-			dev_err(&uac2->pdev.dev,
+			dev_err(&agdev->gadget->dev,
 				"%s:%d Error!\n", __func__, __LINE__);
 			req->status = 0;
 		}
@@ -1573,7 +1520,7 @@ static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
 	struct audio_dev *agdev = func_to_agdev(f);
 	struct uac2_rtd_params *prm;
 
-	alsa_uac2_exit(agdev);
+	snd_uac2_remove(agdev);
 
 	prm = &agdev->uac2.p_prm;
 	kfree(prm->rbuf);
@@ -1582,6 +1529,8 @@ static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
 	kfree(prm->rbuf);
 	kfree(prm->ureq);
 	usb_free_all_descriptors(f);
+
+	agdev->gadget = NULL;
 }
 
 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
-- 
1.9.1

^ permalink raw reply related	[flat|nested] 17+ messages in thread

* [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core
  2017-05-17 22:37 [PATCH v4 0/3] USB Audio Gadget refactoring Ruslan Bilovol
  2017-05-17 22:37 ` [PATCH v4 1/3] usb: gadget: f_uac2: remove platform driver/device creation Ruslan Bilovol
@ 2017-05-17 22:37 ` Ruslan Bilovol
  2017-05-22 15:58   ` Jassi Brar
  2017-06-02  9:34   ` Felipe Balbi
  2017-05-17 22:37 ` [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api Ruslan Bilovol
  2017-06-02  9:42 ` [PATCH v4 0/3] USB Audio Gadget refactoring Felipe Balbi
  3 siblings, 2 replies; 17+ messages in thread
From: Ruslan Bilovol @ 2017-05-17 22:37 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

Abstract the peripheral side ALSA sound card code from
the f_uac2 function into a component that can be called
by various functions, so the various flavors can be split
apart and selectively reused.

Visible changes:
 - add uac_params structure to pass audio paramteres for
   g_audio_setup
 - make ALSA sound card's name configurable
 - add [in/out]_ep_maxpsize
 - allocate snd_uac_chip structure during g_audio_setup
 - add u_audio_[start/stop]_[capture/playback] functions

Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
---
 drivers/usb/gadget/Kconfig            |   4 +
 drivers/usb/gadget/function/Makefile  |   1 +
 drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------
 drivers/usb/gadget/function/u_audio.c | 661 +++++++++++++++++++++++++++++++
 drivers/usb/gadget/function/u_audio.h |  95 +++++
 drivers/usb/gadget/legacy/Kconfig     |   1 +
 6 files changed, 846 insertions(+), 637 deletions(-)
 create mode 100644 drivers/usb/gadget/function/u_audio.c
 create mode 100644 drivers/usb/gadget/function/u_audio.h

diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index c164d6b..2ba0ace 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -158,6 +158,9 @@ config USB_U_SERIAL
 config USB_U_ETHER
 	tristate
 
+config USB_U_AUDIO
+	tristate
+
 config USB_F_SERIAL
 	tristate
 
@@ -381,6 +384,7 @@ config USB_CONFIGFS_F_UAC2
 	depends on SND
 	select USB_LIBCOMPOSITE
 	select SND_PCM
+	select USB_U_AUDIO
 	select USB_F_UAC2
 	help
 	  This Audio function is compatible with USB Audio Class
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
index cb8c225..b29f2ae 100644
--- a/drivers/usb/gadget/function/Makefile
+++ b/drivers/usb/gadget/function/Makefile
@@ -32,6 +32,7 @@ usb_f_mass_storage-y		:= f_mass_storage.o storage_common.o
 obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o
 usb_f_fs-y			:= f_fs.o
 obj-$(CONFIG_USB_F_FS)		+= usb_f_fs.o
+obj-$(CONFIG_USB_U_AUDIO)	+= u_audio.o
 usb_f_uac1-y			:= f_uac1.o u_uac1.o
 obj-$(CONFIG_USB_F_UAC1)	+= usb_f_uac1.o
 usb_f_uac2-y			:= f_uac2.o
diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c
index d4565b5..059a14a 100644
--- a/drivers/usb/gadget/function/f_uac2.c
+++ b/drivers/usb/gadget/function/f_uac2.c
@@ -15,10 +15,7 @@
 #include <linux/usb/audio-v2.h>
 #include <linux/module.h>
 
-#include <sound/core.h>
-#include <sound/pcm.h>
-#include <sound/pcm_params.h>
-
+#include "u_audio.h"
 #include "u_uac2.h"
 
 /*
@@ -50,455 +47,23 @@
 #define UNFLW_CTRL	8
 #define OVFLW_CTRL	10
 
-struct uac2_req {
-	struct uac2_rtd_params *pp; /* parent param */
-	struct usb_request *req;
-};
-
-struct uac2_rtd_params {
-	struct snd_uac2_chip *uac2; /* parent chip */
-	bool ep_enabled; /* if the ep is enabled */
-	/* Size of the ring buffer */
-	size_t dma_bytes;
-	unsigned char *dma_area;
-
-	struct snd_pcm_substream *ss;
-
-	/* Ring buffer */
-	ssize_t hw_ptr;
-
-	void *rbuf;
-
-	size_t period_size;
-
-	unsigned max_psize;
-	struct uac2_req *ureq;
-
-	spinlock_t lock;
-};
-
-struct snd_uac2_chip {
-	struct uac2_rtd_params p_prm;
-	struct uac2_rtd_params c_prm;
-
-	struct snd_card *card;
-	struct snd_pcm *pcm;
-
-	/* timekeeping for the playback endpoint */
-	unsigned int p_interval;
-	unsigned int p_residue;
-
-	/* pre-calculated values for playback iso completion */
-	unsigned int p_pktsize;
-	unsigned int p_pktsize_residue;
-	unsigned int p_framesize;
+struct f_uac2 {
+	struct g_audio g_audio;
+	u8 ac_intf, as_in_intf, as_out_intf;
+	u8 ac_alt, as_in_alt, as_out_alt;	/* needed for get_alt() */
 };
 
-#define BUFF_SIZE_MAX	(PAGE_SIZE * 16)
-#define PRD_SIZE_MAX	PAGE_SIZE
-#define MIN_PERIODS	4
-
-static struct snd_pcm_hardware uac2_pcm_hardware = {
-	.info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
-		 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
-		 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
-	.rates = SNDRV_PCM_RATE_CONTINUOUS,
-	.periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
-	.buffer_bytes_max = BUFF_SIZE_MAX,
-	.period_bytes_max = PRD_SIZE_MAX,
-	.periods_min = MIN_PERIODS,
-};
-
-struct audio_dev {
-	u8 ac_intf, ac_alt;
-	u8 as_out_intf, as_out_alt;
-	u8 as_in_intf, as_in_alt;
-
-	struct usb_ep *in_ep, *out_ep;
-	struct usb_function func;
-	struct usb_gadget *gadget;
-
-	/* The ALSA Sound Card it represents on the USB-Client side */
-	struct snd_uac2_chip uac2;
-};
-
-static inline
-struct audio_dev *func_to_agdev(struct usb_function *f)
+static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
 {
-	return container_of(f, struct audio_dev, func);
+	return container_of(f, struct f_uac2, g_audio.func);
 }
 
 static inline
-struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
-{
-	return container_of(u, struct audio_dev, uac2);
-}
-
-static inline
-struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
+struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
 {
 	return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
 }
 
-static inline
-uint num_channels(uint chanmask)
-{
-	uint num = 0;
-
-	while (chanmask) {
-		num += (chanmask & 1);
-		chanmask >>= 1;
-	}
-
-	return num;
-}
-
-static void
-agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
-{
-	unsigned pending;
-	unsigned long flags;
-	unsigned int hw_ptr;
-	bool update_alsa = false;
-	int status = req->status;
-	struct uac2_req *ur = req->context;
-	struct snd_pcm_substream *substream;
-	struct uac2_rtd_params *prm = ur->pp;
-	struct snd_uac2_chip *uac2 = prm->uac2;
-
-	/* i/f shutting down */
-	if (!prm->ep_enabled || req->status == -ESHUTDOWN)
-		return;
-
-	/*
-	 * We can't really do much about bad xfers.
-	 * Afterall, the ISOCH xfers could fail legitimately.
-	 */
-	if (status)
-		pr_debug("%s: iso_complete status(%d) %d/%d\n",
-			__func__, status, req->actual, req->length);
-
-	substream = prm->ss;
-
-	/* Do nothing if ALSA isn't active */
-	if (!substream)
-		goto exit;
-
-	spin_lock_irqsave(&prm->lock, flags);
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-		/*
-		 * For each IN packet, take the quotient of the current data
-		 * rate and the endpoint's interval as the base packet size.
-		 * If there is a residue from this division, add it to the
-		 * residue accumulator.
-		 */
-		req->length = uac2->p_pktsize;
-		uac2->p_residue += uac2->p_pktsize_residue;
-
-		/*
-		 * Whenever there are more bytes in the accumulator than we
-		 * need to add one more sample frame, increase this packet's
-		 * size and decrease the accumulator.
-		 */
-		if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
-			req->length += uac2->p_framesize;
-			uac2->p_residue -= uac2->p_framesize *
-					   uac2->p_interval;
-		}
-
-		req->actual = req->length;
-	}
-
-	pending = prm->hw_ptr % prm->period_size;
-	pending += req->actual;
-	if (pending >= prm->period_size)
-		update_alsa = true;
-
-	hw_ptr = prm->hw_ptr;
-	prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
-
-	spin_unlock_irqrestore(&prm->lock, flags);
-
-	/* Pack USB load in ALSA ring buffer */
-	pending = prm->dma_bytes - hw_ptr;
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-		if (unlikely(pending < req->actual)) {
-			memcpy(req->buf, prm->dma_area + hw_ptr, pending);
-			memcpy(req->buf + pending, prm->dma_area,
-			       req->actual - pending);
-		} else {
-			memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
-		}
-	} else {
-		if (unlikely(pending < req->actual)) {
-			memcpy(prm->dma_area + hw_ptr, req->buf, pending);
-			memcpy(prm->dma_area, req->buf + pending,
-			       req->actual - pending);
-		} else {
-			memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
-		}
-	}
-
-exit:
-	if (usb_ep_queue(ep, req, GFP_ATOMIC))
-		dev_err(uac2->card->dev, "%d Error!\n", __LINE__);
-
-	if (update_alsa)
-		snd_pcm_period_elapsed(substream);
-
-	return;
-}
-
-static int
-uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
-{
-	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
-	struct audio_dev *agdev = uac2_to_agdev(uac2);
-	struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
-	struct uac2_rtd_params *prm;
-	unsigned long flags;
-	int err = 0;
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-		prm = &uac2->p_prm;
-	else
-		prm = &uac2->c_prm;
-
-	spin_lock_irqsave(&prm->lock, flags);
-
-	/* Reset */
-	prm->hw_ptr = 0;
-
-	switch (cmd) {
-	case SNDRV_PCM_TRIGGER_START:
-	case SNDRV_PCM_TRIGGER_RESUME:
-		prm->ss = substream;
-		break;
-	case SNDRV_PCM_TRIGGER_STOP:
-	case SNDRV_PCM_TRIGGER_SUSPEND:
-		prm->ss = NULL;
-		break;
-	default:
-		err = -EINVAL;
-	}
-
-	spin_unlock_irqrestore(&prm->lock, flags);
-
-	/* Clear buffer after Play stops */
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
-		memset(prm->rbuf, 0, prm->max_psize * uac2_opts->req_number);
-
-	return err;
-}
-
-static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
-{
-	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
-	struct uac2_rtd_params *prm;
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-		prm = &uac2->p_prm;
-	else
-		prm = &uac2->c_prm;
-
-	return bytes_to_frames(substream->runtime, prm->hw_ptr);
-}
-
-static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
-			       struct snd_pcm_hw_params *hw_params)
-{
-	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
-	struct uac2_rtd_params *prm;
-	int err;
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-		prm = &uac2->p_prm;
-	else
-		prm = &uac2->c_prm;
-
-	err = snd_pcm_lib_malloc_pages(substream,
-					params_buffer_bytes(hw_params));
-	if (err >= 0) {
-		prm->dma_bytes = substream->runtime->dma_bytes;
-		prm->dma_area = substream->runtime->dma_area;
-		prm->period_size = params_period_bytes(hw_params);
-	}
-
-	return err;
-}
-
-static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
-	struct uac2_rtd_params *prm;
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-		prm = &uac2->p_prm;
-	else
-		prm = &uac2->c_prm;
-
-	prm->dma_area = NULL;
-	prm->dma_bytes = 0;
-	prm->period_size = 0;
-
-	return snd_pcm_lib_free_pages(substream);
-}
-
-static int uac2_pcm_open(struct snd_pcm_substream *substream)
-{
-	struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
-	struct snd_pcm_runtime *runtime = substream->runtime;
-	struct audio_dev *audio_dev;
-	struct f_uac2_opts *opts;
-	int p_ssize, c_ssize;
-	int p_srate, c_srate;
-	int p_chmask, c_chmask;
-
-	audio_dev = uac2_to_agdev(uac2);
-	opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
-	p_ssize = opts->p_ssize;
-	c_ssize = opts->c_ssize;
-	p_srate = opts->p_srate;
-	c_srate = opts->c_srate;
-	p_chmask = opts->p_chmask;
-	c_chmask = opts->c_chmask;
-	uac2->p_residue = 0;
-
-	runtime->hw = uac2_pcm_hardware;
-
-	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-		spin_lock_init(&uac2->p_prm.lock);
-		runtime->hw.rate_min = p_srate;
-		switch (p_ssize) {
-		case 3:
-			runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
-			break;
-		case 4:
-			runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
-			break;
-		default:
-			runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
-			break;
-		}
-		runtime->hw.channels_min = num_channels(p_chmask);
-		runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
-						/ runtime->hw.periods_min;
-	} else {
-		spin_lock_init(&uac2->c_prm.lock);
-		runtime->hw.rate_min = c_srate;
-		switch (c_ssize) {
-		case 3:
-			runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
-			break;
-		case 4:
-			runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
-			break;
-		default:
-			runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
-			break;
-		}
-		runtime->hw.channels_min = num_channels(c_chmask);
-		runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
-						/ runtime->hw.periods_min;
-	}
-
-	runtime->hw.rate_max = runtime->hw.rate_min;
-	runtime->hw.channels_max = runtime->hw.channels_min;
-
-	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
-
-	return 0;
-}
-
-/* ALSA cries without these function pointers */
-static int uac2_pcm_null(struct snd_pcm_substream *substream)
-{
-	return 0;
-}
-
-static struct snd_pcm_ops uac2_pcm_ops = {
-	.open = uac2_pcm_open,
-	.close = uac2_pcm_null,
-	.ioctl = snd_pcm_lib_ioctl,
-	.hw_params = uac2_pcm_hw_params,
-	.hw_free = uac2_pcm_hw_free,
-	.trigger = uac2_pcm_trigger,
-	.pointer = uac2_pcm_pointer,
-	.prepare = uac2_pcm_null,
-};
-
-static int snd_uac2_probe(struct audio_dev *audio_dev)
-{
-	struct snd_uac2_chip *uac2 = &audio_dev->uac2;
-	struct snd_card *card;
-	struct snd_pcm *pcm;
-	struct f_uac2_opts *opts;
-	int err;
-	int p_chmask, c_chmask;
-
-	opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
-	p_chmask = opts->p_chmask;
-	c_chmask = opts->c_chmask;
-
-	/* Choose any slot, with no id */
-	err = snd_card_new(&audio_dev->gadget->dev,
-			-1, NULL, THIS_MODULE, 0, &card);
-	if (err < 0)
-		return err;
-
-	uac2->card = card;
-
-	/*
-	 * Create first PCM device
-	 * Create a substream only for non-zero channel streams
-	 */
-	err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
-			       p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
-	if (err < 0)
-		goto snd_fail;
-
-	strcpy(pcm->name, "UAC2 PCM");
-	pcm->private_data = uac2;
-
-	uac2->pcm = pcm;
-
-	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
-	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
-
-	strcpy(card->driver, "UAC2_Gadget");
-	strcpy(card->shortname, "UAC2_Gadget");
-	sprintf(card->longname, "UAC2_Gadget %i", card->dev->id);
-
-	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
-		snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
-
-	err = snd_card_register(card);
-
-	if (!err)
-		return 0;
-
-snd_fail:
-	snd_card_free(card);
-
-	uac2->pcm = NULL;
-	uac2->card = NULL;
-
-	return err;
-}
-
-static int snd_uac2_remove(struct audio_dev *audio_dev)
-{
-	struct snd_card *card = audio_dev->uac2.card;
-
-	if (card)
-		return snd_card_free(card);
-
-	return 0;
-}
-
-
 /* --------- USB Function Interface ------------- */
 
 enum {
@@ -886,32 +451,6 @@ struct cntrl_range_lay3 {
 	__u32	dRES;
 } __packed;
 
-static inline void
-free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
-{
-	struct snd_uac2_chip *uac2 = prm->uac2;
-	struct audio_dev *agdev = uac2_to_agdev(uac2);
-	struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
-	int i;
-
-	if (!prm->ep_enabled)
-		return;
-
-	prm->ep_enabled = false;
-
-	for (i = 0; i < uac2_opts->req_number; i++) {
-		if (prm->ureq[i].req) {
-			usb_ep_dequeue(ep, prm->ureq[i].req);
-			usb_ep_free_request(ep, prm->ureq[i].req);
-			prm->ureq[i].req = NULL;
-		}
-	}
-
-	if (usb_ep_disable(ep))
-		dev_err(uac2->card->dev,
-			"%s:%d Error!\n", __func__, __LINE__);
-}
-
 static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	struct usb_endpoint_descriptor *ep_desc,
 	unsigned int factor, bool is_playback)
@@ -938,12 +477,11 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 static int
 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 {
-	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
+	struct f_uac2 *uac2 = func_to_uac2(fn);
+	struct g_audio *agdev = func_to_g_audio(fn);
 	struct usb_composite_dev *cdev = cfg->cdev;
 	struct usb_gadget *gadget = cdev->gadget;
 	struct device *dev = &gadget->dev;
-	struct uac2_rtd_params *prm;
 	struct f_uac2_opts *uac2_opts;
 	struct usb_string *us;
 	int ret;
@@ -990,8 +528,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		return ret;
 	}
 	std_ac_if_desc.bInterfaceNumber = ret;
-	agdev->ac_intf = ret;
-	agdev->ac_alt = 0;
+	uac2->ac_intf = ret;
+	uac2->ac_alt = 0;
 
 	ret = usb_interface_id(cfg, fn);
 	if (ret < 0) {
@@ -1000,8 +538,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	}
 	std_as_out_if0_desc.bInterfaceNumber = ret;
 	std_as_out_if1_desc.bInterfaceNumber = ret;
-	agdev->as_out_intf = ret;
-	agdev->as_out_alt = 0;
+	uac2->as_out_intf = ret;
+	uac2->as_out_alt = 0;
 
 	ret = usb_interface_id(cfg, fn);
 	if (ret < 0) {
@@ -1010,8 +548,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	}
 	std_as_in_if0_desc.bInterfaceNumber = ret;
 	std_as_in_if1_desc.bInterfaceNumber = ret;
-	agdev->as_in_intf = ret;
-	agdev->as_in_alt = 0;
+	uac2->as_in_intf = ret;
+	uac2->as_in_alt = 0;
 
 	agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
 	if (!agdev->out_ep) {
@@ -1025,15 +563,17 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		return ret;
 	}
 
-	uac2->p_prm.uac2 = uac2;
-	uac2->c_prm.uac2 = uac2;
-
 	/* Calculate wMaxPacketSize according to audio bandwidth */
 	set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
 	set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
 	set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
 	set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
 
+	agdev->in_ep_maxpsize = max(fs_epin_desc.wMaxPacketSize,
+					hs_epin_desc.wMaxPacketSize);
+	agdev->out_ep_maxpsize = max(fs_epout_desc.wMaxPacketSize,
+					hs_epout_desc.wMaxPacketSize);
+
 	hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
 	hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 
@@ -1044,46 +584,18 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 
 	agdev->gadget = gadget;
 
-	prm = &agdev->uac2.c_prm;
-	prm->max_psize = hs_epout_desc.wMaxPacketSize;
-	prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
-			GFP_KERNEL);
-	if (!prm->ureq) {
-		ret = -ENOMEM;
-		goto err_free_descs;
-	}
-	prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
-	if (!prm->rbuf) {
-		prm->max_psize = 0;
-		ret = -ENOMEM;
-		goto err_free_descs;
-	}
-
-	prm = &agdev->uac2.p_prm;
-	prm->max_psize = hs_epin_desc.wMaxPacketSize;
-	prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
-			GFP_KERNEL);
-	if (!prm->ureq) {
-		ret = -ENOMEM;
-		goto err_free_descs;
-	}
-	prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
-	if (!prm->rbuf) {
-		prm->max_psize = 0;
-		ret = -ENOMEM;
-		goto err_no_memory;
-	}
-
-	ret = snd_uac2_probe(agdev);
+	agdev->params.p_chmask = uac2_opts->p_chmask;
+	agdev->params.p_srate = uac2_opts->p_srate;
+	agdev->params.p_ssize = uac2_opts->p_ssize;
+	agdev->params.c_chmask = uac2_opts->c_chmask;
+	agdev->params.c_srate = uac2_opts->c_srate;
+	agdev->params.c_ssize = uac2_opts->c_ssize;
+	agdev->params.req_number = uac2_opts->req_number;
+	ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
 	if (ret)
-		goto err_no_memory;
+		goto err_free_descs;
 	return 0;
 
-err_no_memory:
-	kfree(agdev->uac2.p_prm.ureq);
-	kfree(agdev->uac2.c_prm.ureq);
-	kfree(agdev->uac2.p_prm.rbuf);
-	kfree(agdev->uac2.c_prm.rbuf);
 err_free_descs:
 	usb_free_all_descriptors(fn);
 	agdev->gadget = NULL;
@@ -1094,15 +606,10 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
 {
 	struct usb_composite_dev *cdev = fn->config->cdev;
-	struct audio_dev *agdev = func_to_agdev(fn);
-	struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
+	struct f_uac2 *uac2 = func_to_uac2(fn);
 	struct usb_gadget *gadget = cdev->gadget;
 	struct device *dev = &gadget->dev;
-	struct usb_request *req;
-	struct usb_ep *ep;
-	struct uac2_rtd_params *prm;
-	int req_len, i;
+	int ret = 0;
 
 	/* No i/f has more than 2 alt settings */
 	if (alt > 1) {
@@ -1110,7 +617,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		return -EINVAL;
 	}
 
-	if (intf == agdev->ac_intf) {
+	if (intf == uac2->ac_intf) {
 		/* Control I/f has only 1 AltSetting - 0 */
 		if (alt) {
 			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
@@ -1119,92 +626,40 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 		return 0;
 	}
 
-	if (intf == agdev->as_out_intf) {
-		ep = agdev->out_ep;
-		prm = &uac2->c_prm;
-		config_ep_by_speed(gadget, fn, ep);
-		agdev->as_out_alt = alt;
-		req_len = prm->max_psize;
-	} else if (intf == agdev->as_in_intf) {
-		unsigned int factor, rate;
-		struct usb_endpoint_descriptor *ep_desc;
-
-		ep = agdev->in_ep;
-		prm = &uac2->p_prm;
-		config_ep_by_speed(gadget, fn, ep);
-		agdev->as_in_alt = alt;
-
-		/* pre-calculate the playback endpoint's interval */
-		if (gadget->speed == USB_SPEED_FULL) {
-			ep_desc = &fs_epin_desc;
-			factor = 1000;
-		} else {
-			ep_desc = &hs_epin_desc;
-			factor = 8000;
-		}
-
-		/* pre-compute some values for iso_complete() */
-		uac2->p_framesize = opts->p_ssize *
-				    num_channels(opts->p_chmask);
-		rate = opts->p_srate * uac2->p_framesize;
-		uac2->p_interval = factor / (1 << (ep_desc->bInterval - 1));
-		uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
-					prm->max_psize);
+	if (intf == uac2->as_out_intf) {
+		uac2->as_out_alt = alt;
 
-		if (uac2->p_pktsize < prm->max_psize)
-			uac2->p_pktsize_residue = rate % uac2->p_interval;
+		if (alt)
+			ret = u_audio_start_capture(&uac2->g_audio);
 		else
-			uac2->p_pktsize_residue = 0;
+			u_audio_stop_capture(&uac2->g_audio);
+	} else if (intf == uac2->as_in_intf) {
+		uac2->as_in_alt = alt;
 
-		req_len = uac2->p_pktsize;
-		uac2->p_residue = 0;
+		if (alt)
+			ret = u_audio_start_playback(&uac2->g_audio);
+		else
+			u_audio_stop_playback(&uac2->g_audio);
 	} else {
 		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 		return -EINVAL;
 	}
 
-	if (alt == 0) {
-		free_ep(prm, ep);
-		return 0;
-	}
-
-	prm->ep_enabled = true;
-	usb_ep_enable(ep);
-
-	for (i = 0; i < opts->req_number; i++) {
-		if (!prm->ureq[i].req) {
-			req = usb_ep_alloc_request(ep, GFP_ATOMIC);
-			if (req == NULL)
-				return -ENOMEM;
-
-			prm->ureq[i].req = req;
-			prm->ureq[i].pp = prm;
-
-			req->zero = 0;
-			req->context = &prm->ureq[i];
-			req->length = req_len;
-			req->complete = agdev_iso_complete;
-			req->buf = prm->rbuf + i * prm->max_psize;
-		}
-
-		if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
-			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
-	}
-
-	return 0;
+	return ret;
 }
 
 static int
 afunc_get_alt(struct usb_function *fn, unsigned intf)
 {
-	struct audio_dev *agdev = func_to_agdev(fn);
-
-	if (intf == agdev->ac_intf)
-		return agdev->ac_alt;
-	else if (intf == agdev->as_out_intf)
-		return agdev->as_out_alt;
-	else if (intf == agdev->as_in_intf)
-		return agdev->as_in_alt;
+	struct f_uac2 *uac2 = func_to_uac2(fn);
+	struct g_audio *agdev = func_to_g_audio(fn);
+
+	if (intf == uac2->ac_intf)
+		return uac2->ac_alt;
+	else if (intf == uac2->as_out_intf)
+		return uac2->as_out_alt;
+	else if (intf == uac2->as_in_intf)
+		return uac2->as_in_alt;
 	else
 		dev_err(&agdev->gadget->dev,
 			"%s:%d Invalid Interface %d!\n",
@@ -1216,21 +671,19 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 static void
 afunc_disable(struct usb_function *fn)
 {
-	struct audio_dev *agdev = func_to_agdev(fn);
-	struct snd_uac2_chip *uac2 = &agdev->uac2;
-
-	free_ep(&uac2->p_prm, agdev->in_ep);
-	agdev->as_in_alt = 0;
+	struct f_uac2 *uac2 = func_to_uac2(fn);
 
-	free_ep(&uac2->c_prm, agdev->out_ep);
-	agdev->as_out_alt = 0;
+	uac2->as_in_alt = 0;
+	uac2->as_out_alt = 0;
+	u_audio_stop_capture(&uac2->g_audio);
+	u_audio_stop_playback(&uac2->g_audio);
 }
 
 static int
 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 {
 	struct usb_request *req = fn->config->cdev->req;
-	struct audio_dev *agdev = func_to_agdev(fn);
+	struct g_audio *agdev = func_to_g_audio(fn);
 	struct f_uac2_opts *opts;
 	u16 w_length = le16_to_cpu(cr->wLength);
 	u16 w_index = le16_to_cpu(cr->wIndex);
@@ -1240,7 +693,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	int value = -EOPNOTSUPP;
 	int p_srate, c_srate;
 
-	opts = agdev_to_uac2_opts(agdev);
+	opts = g_audio_to_uac2_opts(agdev);
 	p_srate = opts->p_srate;
 	c_srate = opts->c_srate;
 
@@ -1271,7 +724,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 {
 	struct usb_request *req = fn->config->cdev->req;
-	struct audio_dev *agdev = func_to_agdev(fn);
+	struct g_audio *agdev = func_to_g_audio(fn);
 	struct f_uac2_opts *opts;
 	u16 w_length = le16_to_cpu(cr->wLength);
 	u16 w_index = le16_to_cpu(cr->wIndex);
@@ -1282,7 +735,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 	int value = -EOPNOTSUPP;
 	int p_srate, c_srate;
 
-	opts = agdev_to_uac2_opts(agdev);
+	opts = g_audio_to_uac2_opts(agdev);
 	p_srate = opts->p_srate;
 	c_srate = opts->c_srate;
 
@@ -1336,11 +789,12 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 static int
 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 {
-	struct audio_dev *agdev = func_to_agdev(fn);
+	struct f_uac2 *uac2 = func_to_uac2(fn);
+	struct g_audio *agdev = func_to_g_audio(fn);
 	u16 w_index = le16_to_cpu(cr->wIndex);
 	u8 intf = w_index & 0xff;
 
-	if (intf != agdev->ac_intf) {
+	if (intf != uac2->ac_intf) {
 		dev_err(&agdev->gadget->dev,
 			"%s:%d Error!\n", __func__, __LINE__);
 		return -EOPNOTSUPP;
@@ -1358,7 +812,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 {
 	struct usb_composite_dev *cdev = fn->config->cdev;
-	struct audio_dev *agdev = func_to_agdev(fn);
+	struct g_audio *agdev = func_to_g_audio(fn);
 	struct usb_request *req = cdev->req;
 	u16 w_length = le16_to_cpu(cr->wLength);
 	int value = -EOPNOTSUPP;
@@ -1504,10 +958,10 @@ static struct usb_function_instance *afunc_alloc_inst(void)
 
 static void afunc_free(struct usb_function *f)
 {
-	struct audio_dev *agdev;
+	struct g_audio *agdev;
 	struct f_uac2_opts *opts;
 
-	agdev = func_to_agdev(f);
+	agdev = func_to_g_audio(f);
 	opts = container_of(f->fi, struct f_uac2_opts, func_inst);
 	kfree(agdev);
 	mutex_lock(&opts->lock);
@@ -1517,17 +971,9 @@ static void afunc_free(struct usb_function *f)
 
 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
 {
-	struct audio_dev *agdev = func_to_agdev(f);
-	struct uac2_rtd_params *prm;
-
-	snd_uac2_remove(agdev);
-
-	prm = &agdev->uac2.p_prm;
-	kfree(prm->rbuf);
+	struct g_audio *agdev = func_to_g_audio(f);
 
-	prm = &agdev->uac2.c_prm;
-	kfree(prm->rbuf);
-	kfree(prm->ureq);
+	g_audio_cleanup(agdev);
 	usb_free_all_descriptors(f);
 
 	agdev->gadget = NULL;
@@ -1535,11 +981,11 @@ static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
 
 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
 {
-	struct audio_dev *agdev;
+	struct f_uac2	*uac2;
 	struct f_uac2_opts *opts;
 
-	agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
-	if (agdev == NULL)
+	uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
+	if (uac2 == NULL)
 		return ERR_PTR(-ENOMEM);
 
 	opts = container_of(fi, struct f_uac2_opts, func_inst);
@@ -1547,19 +993,20 @@ static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
 	++opts->refcnt;
 	mutex_unlock(&opts->lock);
 
-	agdev->func.name = "uac2_func";
-	agdev->func.bind = afunc_bind;
-	agdev->func.unbind = afunc_unbind;
-	agdev->func.set_alt = afunc_set_alt;
-	agdev->func.get_alt = afunc_get_alt;
-	agdev->func.disable = afunc_disable;
-	agdev->func.setup = afunc_setup;
-	agdev->func.free_func = afunc_free;
+	uac2->g_audio.func.name = "uac2_func";
+	uac2->g_audio.func.bind = afunc_bind;
+	uac2->g_audio.func.unbind = afunc_unbind;
+	uac2->g_audio.func.set_alt = afunc_set_alt;
+	uac2->g_audio.func.get_alt = afunc_get_alt;
+	uac2->g_audio.func.disable = afunc_disable;
+	uac2->g_audio.func.setup = afunc_setup;
+	uac2->g_audio.func.free_func = afunc_free;
 
-	return &agdev->func;
+	return &uac2->g_audio.func;
 }
 
 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Yadwinder Singh");
 MODULE_AUTHOR("Jaswinder Singh");
+MODULE_AUTHOR("Ruslan Bilovol");
diff --git a/drivers/usb/gadget/function/u_audio.c b/drivers/usb/gadget/function/u_audio.c
new file mode 100644
index 0000000..8ee65b8
--- /dev/null
+++ b/drivers/usb/gadget/function/u_audio.c
@@ -0,0 +1,661 @@
+/*
+ * u_audio.c -- interface to USB gadget "ALSA sound card" utilities
+ *
+ * Copyright (C) 2016
+ * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
+ *
+ * Based on f_uac2.c which is:
+ *    Copyright (C) 2011
+ *    Yadwinder Singh (yadi.brar01@gmail.com)
+ *    Jaswinder Singh (jaswinder.singh@linaro.org)
+ *
+ * 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.
+ */
+
+#include <linux/module.h>
+#include <sound/core.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+
+#include "u_audio.h"
+
+#define BUFF_SIZE_MAX	(PAGE_SIZE * 16)
+#define PRD_SIZE_MAX	PAGE_SIZE
+#define MIN_PERIODS	4
+
+struct uac_req {
+	struct uac_rtd_params *pp; /* parent param */
+	struct usb_request *req;
+};
+
+/* Runtime data params for one stream */
+struct uac_rtd_params {
+	struct snd_uac_chip *uac; /* parent chip */
+	bool ep_enabled; /* if the ep is enabled */
+	/* Size of the ring buffer */
+	size_t dma_bytes;
+	unsigned char *dma_area;
+
+	struct snd_pcm_substream *ss;
+
+	/* Ring buffer */
+	ssize_t hw_ptr;
+
+	void *rbuf;
+
+	size_t period_size;
+
+	unsigned max_psize;	/* MaxPacketSize of endpoint */
+	struct uac_req *ureq;
+
+	spinlock_t lock;
+};
+
+struct snd_uac_chip {
+	struct g_audio *audio_dev;
+
+	struct uac_rtd_params p_prm;
+	struct uac_rtd_params c_prm;
+
+	struct snd_card *card;
+	struct snd_pcm *pcm;
+
+	/* timekeeping for the playback endpoint */
+	unsigned int p_interval;
+	unsigned int p_residue;
+
+	/* pre-calculated values for playback iso completion */
+	unsigned int p_pktsize;
+	unsigned int p_pktsize_residue;
+	unsigned int p_framesize;
+};
+
+static struct snd_pcm_hardware uac_pcm_hardware = {
+	.info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
+		 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
+		 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
+	.rates = SNDRV_PCM_RATE_CONTINUOUS,
+	.periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
+	.buffer_bytes_max = BUFF_SIZE_MAX,
+	.period_bytes_max = PRD_SIZE_MAX,
+	.periods_min = MIN_PERIODS,
+};
+
+static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req)
+{
+	unsigned pending;
+	unsigned long flags;
+	unsigned int hw_ptr;
+	bool update_alsa = false;
+	int status = req->status;
+	struct uac_req *ur = req->context;
+	struct snd_pcm_substream *substream;
+	struct uac_rtd_params *prm = ur->pp;
+	struct snd_uac_chip *uac = prm->uac;
+
+	/* i/f shutting down */
+	if (!prm->ep_enabled || req->status == -ESHUTDOWN)
+		return;
+
+	/*
+	 * We can't really do much about bad xfers.
+	 * Afterall, the ISOCH xfers could fail legitimately.
+	 */
+	if (status)
+		pr_debug("%s: iso_complete status(%d) %d/%d\n",
+			__func__, status, req->actual, req->length);
+
+	substream = prm->ss;
+
+	/* Do nothing if ALSA isn't active */
+	if (!substream)
+		goto exit;
+
+	spin_lock_irqsave(&prm->lock, flags);
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+		/*
+		 * For each IN packet, take the quotient of the current data
+		 * rate and the endpoint's interval as the base packet size.
+		 * If there is a residue from this division, add it to the
+		 * residue accumulator.
+		 */
+		req->length = uac->p_pktsize;
+		uac->p_residue += uac->p_pktsize_residue;
+
+		/*
+		 * Whenever there are more bytes in the accumulator than we
+		 * need to add one more sample frame, increase this packet's
+		 * size and decrease the accumulator.
+		 */
+		if (uac->p_residue / uac->p_interval >= uac->p_framesize) {
+			req->length += uac->p_framesize;
+			uac->p_residue -= uac->p_framesize *
+					   uac->p_interval;
+		}
+
+		req->actual = req->length;
+	}
+
+	pending = prm->hw_ptr % prm->period_size;
+	pending += req->actual;
+	if (pending >= prm->period_size)
+		update_alsa = true;
+
+	hw_ptr = prm->hw_ptr;
+	prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
+
+	spin_unlock_irqrestore(&prm->lock, flags);
+
+	/* Pack USB load in ALSA ring buffer */
+	pending = prm->dma_bytes - hw_ptr;
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+		if (unlikely(pending < req->actual)) {
+			memcpy(req->buf, prm->dma_area + hw_ptr, pending);
+			memcpy(req->buf + pending, prm->dma_area,
+			       req->actual - pending);
+		} else {
+			memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
+		}
+	} else {
+		if (unlikely(pending < req->actual)) {
+			memcpy(prm->dma_area + hw_ptr, req->buf, pending);
+			memcpy(prm->dma_area, req->buf + pending,
+			       req->actual - pending);
+		} else {
+			memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
+		}
+	}
+
+exit:
+	if (usb_ep_queue(ep, req, GFP_ATOMIC))
+		dev_err(uac->card->dev, "%d Error!\n", __LINE__);
+
+	if (update_alsa)
+		snd_pcm_period_elapsed(substream);
+}
+
+static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
+{
+	struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
+	struct uac_rtd_params *prm;
+	struct g_audio *audio_dev;
+	struct uac_params *params;
+	unsigned long flags;
+	int err = 0;
+
+	audio_dev = uac->audio_dev;
+	params = &audio_dev->params;
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+		prm = &uac->p_prm;
+	else
+		prm = &uac->c_prm;
+
+	spin_lock_irqsave(&prm->lock, flags);
+
+	/* Reset */
+	prm->hw_ptr = 0;
+
+	switch (cmd) {
+	case SNDRV_PCM_TRIGGER_START:
+	case SNDRV_PCM_TRIGGER_RESUME:
+		prm->ss = substream;
+		break;
+	case SNDRV_PCM_TRIGGER_STOP:
+	case SNDRV_PCM_TRIGGER_SUSPEND:
+		prm->ss = NULL;
+		break;
+	default:
+		err = -EINVAL;
+	}
+
+	spin_unlock_irqrestore(&prm->lock, flags);
+
+	/* Clear buffer after Play stops */
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
+		memset(prm->rbuf, 0, prm->max_psize * params->req_number);
+
+	return err;
+}
+
+static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream)
+{
+	struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
+	struct uac_rtd_params *prm;
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+		prm = &uac->p_prm;
+	else
+		prm = &uac->c_prm;
+
+	return bytes_to_frames(substream->runtime, prm->hw_ptr);
+}
+
+static int uac_pcm_hw_params(struct snd_pcm_substream *substream,
+			       struct snd_pcm_hw_params *hw_params)
+{
+	struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
+	struct uac_rtd_params *prm;
+	int err;
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+		prm = &uac->p_prm;
+	else
+		prm = &uac->c_prm;
+
+	err = snd_pcm_lib_malloc_pages(substream,
+					params_buffer_bytes(hw_params));
+	if (err >= 0) {
+		prm->dma_bytes = substream->runtime->dma_bytes;
+		prm->dma_area = substream->runtime->dma_area;
+		prm->period_size = params_period_bytes(hw_params);
+	}
+
+	return err;
+}
+
+static int uac_pcm_hw_free(struct snd_pcm_substream *substream)
+{
+	struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
+	struct uac_rtd_params *prm;
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+		prm = &uac->p_prm;
+	else
+		prm = &uac->c_prm;
+
+	prm->dma_area = NULL;
+	prm->dma_bytes = 0;
+	prm->period_size = 0;
+
+	return snd_pcm_lib_free_pages(substream);
+}
+
+static int uac_pcm_open(struct snd_pcm_substream *substream)
+{
+	struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
+	struct snd_pcm_runtime *runtime = substream->runtime;
+	struct g_audio *audio_dev;
+	struct uac_params *params;
+	int p_ssize, c_ssize;
+	int p_srate, c_srate;
+	int p_chmask, c_chmask;
+
+	audio_dev = uac->audio_dev;
+	params = &audio_dev->params;
+	p_ssize = params->p_ssize;
+	c_ssize = params->c_ssize;
+	p_srate = params->p_srate;
+	c_srate = params->c_srate;
+	p_chmask = params->p_chmask;
+	c_chmask = params->c_chmask;
+	uac->p_residue = 0;
+
+	runtime->hw = uac_pcm_hardware;
+
+	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+		spin_lock_init(&uac->p_prm.lock);
+		runtime->hw.rate_min = p_srate;
+		switch (p_ssize) {
+		case 3:
+			runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
+			break;
+		case 4:
+			runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
+			break;
+		default:
+			runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
+			break;
+		}
+		runtime->hw.channels_min = num_channels(p_chmask);
+		runtime->hw.period_bytes_min = 2 * uac->p_prm.max_psize
+						/ runtime->hw.periods_min;
+	} else {
+		spin_lock_init(&uac->c_prm.lock);
+		runtime->hw.rate_min = c_srate;
+		switch (c_ssize) {
+		case 3:
+			runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
+			break;
+		case 4:
+			runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
+			break;
+		default:
+			runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
+			break;
+		}
+		runtime->hw.channels_min = num_channels(c_chmask);
+		runtime->hw.period_bytes_min = 2 * uac->c_prm.max_psize
+						/ runtime->hw.periods_min;
+	}
+
+	runtime->hw.rate_max = runtime->hw.rate_min;
+	runtime->hw.channels_max = runtime->hw.channels_min;
+
+	snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
+
+	return 0;
+}
+
+/* ALSA cries without these function pointers */
+static int uac_pcm_null(struct snd_pcm_substream *substream)
+{
+	return 0;
+}
+
+static struct snd_pcm_ops uac_pcm_ops = {
+	.open = uac_pcm_open,
+	.close = uac_pcm_null,
+	.ioctl = snd_pcm_lib_ioctl,
+	.hw_params = uac_pcm_hw_params,
+	.hw_free = uac_pcm_hw_free,
+	.trigger = uac_pcm_trigger,
+	.pointer = uac_pcm_pointer,
+	.prepare = uac_pcm_null,
+};
+
+static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep)
+{
+	struct snd_uac_chip *uac = prm->uac;
+	struct g_audio *audio_dev;
+	struct uac_params *params;
+	int i;
+
+	if (!prm->ep_enabled)
+		return;
+
+	prm->ep_enabled = false;
+
+	audio_dev = uac->audio_dev;
+	params = &audio_dev->params;
+
+	for (i = 0; i < params->req_number; i++) {
+		if (prm->ureq[i].req) {
+			usb_ep_dequeue(ep, prm->ureq[i].req);
+			usb_ep_free_request(ep, prm->ureq[i].req);
+			prm->ureq[i].req = NULL;
+		}
+	}
+
+	if (usb_ep_disable(ep))
+		dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
+}
+
+
+int u_audio_start_capture(struct g_audio *audio_dev)
+{
+	struct snd_uac_chip *uac = audio_dev->uac;
+	struct usb_gadget *gadget = audio_dev->gadget;
+	struct device *dev = &gadget->dev;
+	struct usb_request *req;
+	struct usb_ep *ep;
+	struct uac_rtd_params *prm;
+	struct uac_params *params = &audio_dev->params;
+	int req_len, i;
+
+	ep = audio_dev->out_ep;
+	prm = &uac->c_prm;
+	config_ep_by_speed(gadget, &audio_dev->func, ep);
+	req_len = prm->max_psize;
+
+	prm->ep_enabled = true;
+	usb_ep_enable(ep);
+
+	for (i = 0; i < params->req_number; i++) {
+		if (!prm->ureq[i].req) {
+			req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+			if (req == NULL)
+				return -ENOMEM;
+
+			prm->ureq[i].req = req;
+			prm->ureq[i].pp = prm;
+
+			req->zero = 0;
+			req->context = &prm->ureq[i];
+			req->length = req_len;
+			req->complete = u_audio_iso_complete;
+			req->buf = prm->rbuf + i * prm->max_psize;
+		}
+
+		if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
+			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(u_audio_start_capture);
+
+void u_audio_stop_capture(struct g_audio *audio_dev)
+{
+	struct snd_uac_chip *uac = audio_dev->uac;
+
+	free_ep(&uac->c_prm, audio_dev->out_ep);
+}
+EXPORT_SYMBOL_GPL(u_audio_stop_capture);
+
+int u_audio_start_playback(struct g_audio *audio_dev)
+{
+	struct snd_uac_chip *uac = audio_dev->uac;
+	struct usb_gadget *gadget = audio_dev->gadget;
+	struct device *dev = &gadget->dev;
+	struct usb_request *req;
+	struct usb_ep *ep;
+	struct uac_rtd_params *prm;
+	struct uac_params *params = &audio_dev->params;
+	unsigned int factor, rate;
+	const struct usb_endpoint_descriptor *ep_desc;
+	int req_len, i;
+
+	ep = audio_dev->in_ep;
+	prm = &uac->p_prm;
+	config_ep_by_speed(gadget, &audio_dev->func, ep);
+
+	ep_desc = ep->desc;
+
+	/* pre-calculate the playback endpoint's interval */
+	if (gadget->speed == USB_SPEED_FULL)
+		factor = 1000;
+	else
+		factor = 8000;
+
+	/* pre-compute some values for iso_complete() */
+	uac->p_framesize = params->p_ssize *
+			    num_channels(params->p_chmask);
+	rate = params->p_srate * uac->p_framesize;
+	uac->p_interval = factor / (1 << (ep_desc->bInterval - 1));
+	uac->p_pktsize = min_t(unsigned int, rate / uac->p_interval,
+				prm->max_psize);
+
+	if (uac->p_pktsize < prm->max_psize)
+		uac->p_pktsize_residue = rate % uac->p_interval;
+	else
+		uac->p_pktsize_residue = 0;
+
+	req_len = uac->p_pktsize;
+	uac->p_residue = 0;
+
+	prm->ep_enabled = true;
+	usb_ep_enable(ep);
+
+	for (i = 0; i < params->req_number; i++) {
+		if (!prm->ureq[i].req) {
+			req = usb_ep_alloc_request(ep, GFP_ATOMIC);
+			if (req == NULL)
+				return -ENOMEM;
+
+			prm->ureq[i].req = req;
+			prm->ureq[i].pp = prm;
+
+			req->zero = 0;
+			req->context = &prm->ureq[i];
+			req->length = req_len;
+			req->complete = u_audio_iso_complete;
+			req->buf = prm->rbuf + i * prm->max_psize;
+		}
+
+		if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
+			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(u_audio_start_playback);
+
+void u_audio_stop_playback(struct g_audio *audio_dev)
+{
+	struct snd_uac_chip *uac = audio_dev->uac;
+
+	free_ep(&uac->p_prm, audio_dev->in_ep);
+}
+EXPORT_SYMBOL_GPL(u_audio_stop_playback);
+
+int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
+					const char *card_name)
+{
+	struct snd_uac_chip *uac;
+	struct snd_card *card;
+	struct snd_pcm *pcm;
+	struct uac_params *params;
+	int p_chmask, c_chmask;
+	int err;
+
+	if (!g_audio)
+		return -EINVAL;
+
+	uac = kzalloc(sizeof(*uac), GFP_KERNEL);
+	if (!uac)
+		return -ENOMEM;
+	g_audio->uac = uac;
+	uac->audio_dev = g_audio;
+
+	params = &g_audio->params;
+	p_chmask = params->p_chmask;
+	c_chmask = params->c_chmask;
+
+	if (c_chmask) {
+		struct uac_rtd_params *prm = &uac->c_prm;
+
+		uac->c_prm.uac = uac;
+		prm->max_psize = g_audio->out_ep_maxpsize;
+
+		prm->ureq = kcalloc(params->req_number, sizeof(struct uac_req),
+				GFP_KERNEL);
+		if (!prm->ureq) {
+			err = -ENOMEM;
+			goto fail;
+		}
+
+		prm->rbuf = kcalloc(params->req_number, prm->max_psize,
+				GFP_KERNEL);
+		if (!prm->rbuf) {
+			prm->max_psize = 0;
+			err = -ENOMEM;
+			goto fail;
+		}
+	}
+
+	if (p_chmask) {
+		struct uac_rtd_params *prm = &uac->p_prm;
+
+		uac->p_prm.uac = uac;
+		prm->max_psize = g_audio->in_ep_maxpsize;
+
+		prm->ureq = kcalloc(params->req_number, sizeof(struct uac_req),
+				GFP_KERNEL);
+		if (!prm->ureq) {
+			err = -ENOMEM;
+			goto fail;
+		}
+
+		prm->rbuf = kcalloc(params->req_number, prm->max_psize,
+				GFP_KERNEL);
+		if (!prm->rbuf) {
+			prm->max_psize = 0;
+			err = -ENOMEM;
+			goto fail;
+		}
+	}
+
+	/* Choose any slot, with no id */
+	err = snd_card_new(&g_audio->gadget->dev,
+			-1, NULL, THIS_MODULE, 0, &card);
+	if (err < 0)
+		goto fail;
+
+	uac->card = card;
+
+	/*
+	 * Create first PCM device
+	 * Create a substream only for non-zero channel streams
+	 */
+	err = snd_pcm_new(uac->card, pcm_name, 0,
+			       p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
+	if (err < 0)
+		goto snd_fail;
+
+	strcpy(pcm->name, pcm_name);
+	pcm->private_data = uac;
+	uac->pcm = pcm;
+
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops);
+	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops);
+
+	strcpy(card->driver, card_name);
+	strcpy(card->shortname, card_name);
+	sprintf(card->longname, "%s %i", card_name, card->dev->id);
+
+	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
+		snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
+
+	err = snd_card_register(card);
+
+	if (!err)
+		return 0;
+
+snd_fail:
+	snd_card_free(card);
+fail:
+	kfree(uac->p_prm.ureq);
+	kfree(uac->c_prm.ureq);
+	kfree(uac->p_prm.rbuf);
+	kfree(uac->c_prm.rbuf);
+	kfree(uac);
+
+	return err;
+}
+EXPORT_SYMBOL_GPL(g_audio_setup);
+
+void g_audio_cleanup(struct g_audio *g_audio)
+{
+	struct snd_uac_chip *uac;
+	struct snd_card *card;
+
+	if (!g_audio || !g_audio->uac)
+		return;
+
+	uac = g_audio->uac;
+	card = uac->card;
+	if (card)
+		snd_card_free(card);
+
+	kfree(uac->p_prm.ureq);
+	kfree(uac->c_prm.ureq);
+	kfree(uac->p_prm.rbuf);
+	kfree(uac->c_prm.rbuf);
+	kfree(uac);
+}
+EXPORT_SYMBOL_GPL(g_audio_cleanup);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities");
+MODULE_AUTHOR("Ruslan Bilovol");
diff --git a/drivers/usb/gadget/function/u_audio.h b/drivers/usb/gadget/function/u_audio.h
new file mode 100644
index 0000000..07e1378
--- /dev/null
+++ b/drivers/usb/gadget/function/u_audio.h
@@ -0,0 +1,95 @@
+/*
+ * u_audio.h -- interface to USB gadget "ALSA sound card" utilities
+ *
+ * Copyright (C) 2016
+ * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
+ *
+ * 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.
+ *
+ */
+
+#ifndef __U_AUDIO_H
+#define __U_AUDIO_H
+
+#include <linux/usb/composite.h>
+
+struct uac_params {
+	/* playback */
+	int p_chmask;	/* channel mask */
+	int p_srate;	/* rate in Hz */
+	int p_ssize;	/* sample size */
+
+	/* capture */
+	int c_chmask;	/* channel mask */
+	int c_srate;	/* rate in Hz */
+	int c_ssize;	/* sample size */
+
+	int req_number; /* number of preallocated requests */
+};
+
+struct g_audio {
+	struct usb_function func;
+	struct usb_gadget *gadget;
+
+	struct usb_ep *in_ep;
+	struct usb_ep *out_ep;
+
+	/* Max packet size for all in_ep possible speeds */
+	unsigned int in_ep_maxpsize;
+	/* Max packet size for all out_ep possible speeds */
+	unsigned int out_ep_maxpsize;
+
+	/* The ALSA Sound Card it represents on the USB-Client side */
+	struct snd_uac_chip *uac;
+
+	struct uac_params params;
+};
+
+static inline struct g_audio *func_to_g_audio(struct usb_function *f)
+{
+	return container_of(f, struct g_audio, func);
+}
+
+static inline uint num_channels(uint chanmask)
+{
+	uint num = 0;
+
+	while (chanmask) {
+		num += (chanmask & 1);
+		chanmask >>= 1;
+	}
+
+	return num;
+}
+
+/*
+ * g_audio_setup - initialize one virtual ALSA sound card
+ * @g_audio: struct with filled params, in_ep_maxpsize, out_ep_maxpsize
+ * @pcm_name: the id string for a PCM instance of this sound card
+ * @card_name: name of this soundcard
+ *
+ * This sets up the single virtual ALSA sound card that may be exported by a
+ * gadget driver using this framework.
+ *
+ * Context: may sleep
+ *
+ * Returns zero on success, or a negative error on failure.
+ */
+int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
+					const char *card_name);
+void g_audio_cleanup(struct g_audio *g_audio);
+
+int u_audio_start_capture(struct g_audio *g_audio);
+void u_audio_stop_capture(struct g_audio *g_audio);
+int u_audio_start_playback(struct g_audio *g_audio);
+void u_audio_stop_playback(struct g_audio *g_audio);
+
+#endif /* __U_AUDIO_H */
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
index 0b36878..5344064 100644
--- a/drivers/usb/gadget/legacy/Kconfig
+++ b/drivers/usb/gadget/legacy/Kconfig
@@ -56,6 +56,7 @@ config USB_AUDIO
 	select SND_PCM
 	select USB_F_UAC1 if GADGET_UAC1
 	select USB_F_UAC2 if !GADGET_UAC1
+	select USB_U_AUDIO if USB_F_UAC2
 	help
 	  This Gadget Audio driver is compatible with USB Audio Class
 	  specification 2.0. It implements 1 AudioControl interface,
-- 
1.9.1

^ permalink raw reply related	[flat|nested] 17+ messages in thread

* [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api
  2017-05-17 22:37 [PATCH v4 0/3] USB Audio Gadget refactoring Ruslan Bilovol
  2017-05-17 22:37 ` [PATCH v4 1/3] usb: gadget: f_uac2: remove platform driver/device creation Ruslan Bilovol
  2017-05-17 22:37 ` [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core Ruslan Bilovol
@ 2017-05-17 22:37 ` Ruslan Bilovol
  2017-05-26 15:52   ` Julian Scheel
  2017-06-02  9:42 ` [PATCH v4 0/3] USB Audio Gadget refactoring Felipe Balbi
  3 siblings, 1 reply; 17+ messages in thread
From: Ruslan Bilovol @ 2017-05-17 22:37 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

This patch adds a new function 'f_uac1_acard'
(f_uac1 with virtual "ALSA card") that
uses recently created u_audio API. Comparing
to legacy f_uac1 function implementation it
doesn't require any real Audio codec to be
present on the device. In f_uac1_acard audio
streams are simply sinked to and sourced
from a virtual ALSA sound card created
using u_audio API.

Legacy f_uac1 approach is to write audio
samples directly to existing ALSA sound
card

f_uac1_acard approach is more generic/flexible
one - create an ALSA sound card that
represents USB Audio function and allows to
be used by userspace application that
may choose to do whatever it wants with the
data received from the USB Host and choose
to provide whatever it wants as audio data
to the USB Host.

f_uac1_acard also has capture support (gadget->host)
thanks to easy implementation via u_audio.
By default, capture interface has 48000kHz/2ch
configuration, same as playback channel has.

f_uac1_acard descriptors naming convention
uses f_uac2 driver naming convention that
makes it more common and meaningful.

Comparing to f_uac1, the f_uac1_acard doesn't
have volume/mute functionality. This is because
the f_uac1 volume/mute feature unit was dummy
implementation since that driver creation (2009)
and never had any real volume control or mute
functionality, so there is no any difference
here.

Since f_uac1_acard functionality, exposed
interface to userspace (virtual ALSA card),
input parameters are so different comparing
to legace f_uac1, that there is no any
reason to keep them in the same file/module,
and separate function was created.

g_audio can be built using one of existing
UAC functions (f_uac1, f_uac1_acard or f_uac2)

Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
---
 .../ABI/testing/configfs-usb-gadget-uac1_acard     |  14 +
 Documentation/usb/gadget-testing.txt               |  45 ++
 drivers/usb/gadget/Kconfig                         |  21 +
 drivers/usb/gadget/function/Makefile               |   2 +
 drivers/usb/gadget/function/f_uac1_acard.c         | 803 +++++++++++++++++++++
 drivers/usb/gadget/function/u_uac1_acard.h         |  41 ++
 drivers/usb/gadget/legacy/Kconfig                  |  15 +-
 drivers/usb/gadget/legacy/audio.c                  |  53 ++
 8 files changed, 992 insertions(+), 2 deletions(-)
 create mode 100644 Documentation/ABI/testing/configfs-usb-gadget-uac1_acard
 create mode 100644 drivers/usb/gadget/function/f_uac1_acard.c
 create mode 100644 drivers/usb/gadget/function/u_uac1_acard.h

diff --git a/Documentation/ABI/testing/configfs-usb-gadget-uac1_acard b/Documentation/ABI/testing/configfs-usb-gadget-uac1_acard
new file mode 100644
index 0000000..2cffeaa
--- /dev/null
+++ b/Documentation/ABI/testing/configfs-usb-gadget-uac1_acard
@@ -0,0 +1,14 @@
+What:		/config/usb-gadget/gadget/functions/uac1_acard.name
+Date:		May 2017
+KernelVersion:	4.13
+Description:
+		The attributes:
+
+		c_chmask - capture channel mask
+		c_srate - capture sampling rate
+		c_ssize - capture sample size (bytes)
+		p_chmask - playback channel mask
+		p_srate - playback sampling rate
+		p_ssize - playback sample size (bytes)
+		req_number - the number of pre-allocated request
+			for both capture and playback
diff --git a/Documentation/usb/gadget-testing.txt b/Documentation/usb/gadget-testing.txt
index fb0cc4d..ecff3ec 100644
--- a/Documentation/usb/gadget-testing.txt
+++ b/Documentation/usb/gadget-testing.txt
@@ -20,6 +20,7 @@ provided by gadgets.
 17. UAC2 function
 18. UVC function
 19. PRINTER function
+20. UAC1 function (new API)
 
 
 1. ACM function
@@ -772,3 +773,47 @@ host:
 
 More advanced testing can be done with the prn_example
 described in Documentation/usb/gadget-printer.txt.
+
+
+20. UAC1 function (virtual ALSA card, using u_audio API)
+=================
+
+The function is provided by usb_f_uac1_acard.ko module.
+It will create a virtual ALSA card and the audio streams are simply
+sinked to and sourced from it.
+
+Function-specific configfs interface
+------------------------------------
+
+The function name to use when creating the function directory
+is "uac1_acard". The uac1_acard function provides these attributes
+in its function directory:
+
+	c_chmask - capture channel mask
+	c_srate - capture sampling rate
+	c_ssize - capture sample size (bytes)
+	p_chmask - playback channel mask
+	p_srate - playback sampling rate
+	p_ssize - playback sample size (bytes)
+	req_number - the number of pre-allocated request for both capture
+		     and playback
+
+The attributes have sane default values.
+
+Testing the UAC1 function
+-------------------------
+
+device: run the gadget
+host: aplay -l # should list our USB Audio Gadget
+
+This function does not require real hardware support, it just
+sends a stream of audio data to/from the host. In order to
+actually hear something at the device side, a command similar
+to this must be used at the device side:
+
+$ arecord -f dat -t wav -D hw:2,0 | aplay -D hw:0,0 &
+
+e.g.:
+
+$ arecord -f dat -t wav -D hw:CARD=UAC1Gadget,DEV=0 | \
+aplay -D default:CARD=OdroidU3
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 2ba0ace..765089c 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -194,6 +194,9 @@ config USB_F_FS
 config USB_F_UAC1
 	tristate
 
+config USB_F_UAC1_ACARD
+	tristate
+
 config USB_F_UAC2
 	tristate
 
@@ -378,6 +381,24 @@ config USB_CONFIGFS_F_UAC1
 	  This driver requires a real Audio codec to be present
 	  on the device.
 
+config USB_CONFIGFS_F_UAC1_ACARD
+	bool "Audio Class 1.0 (Virtual ALSA Card)"
+	depends on USB_CONFIGFS
+	depends on SND
+	select USB_LIBCOMPOSITE
+	select SND_PCM
+	select USB_U_AUDIO
+	select USB_F_UAC1_ACARD
+	help
+	  This Audio function implements 1 AudioControl interface,
+	  1 AudioStreaming Interface each for USB-OUT and USB-IN.
+	  This driver doesn't expect any real Audio codec to be present
+	  on the device - the audio streams are simply sinked to and
+	  sourced from a virtual ALSA sound card created. The user-space
+	  application may choose to do whatever it wants with the data
+	  received from the USB Host and choose to provide whatever it
+	  wants as audio data to the USB Host.
+
 config USB_CONFIGFS_F_UAC2
 	bool "Audio Class 2.0"
 	depends on USB_CONFIGFS
diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
index b29f2ae..04ccde4 100644
--- a/drivers/usb/gadget/function/Makefile
+++ b/drivers/usb/gadget/function/Makefile
@@ -35,6 +35,8 @@ obj-$(CONFIG_USB_F_FS)		+= usb_f_fs.o
 obj-$(CONFIG_USB_U_AUDIO)	+= u_audio.o
 usb_f_uac1-y			:= f_uac1.o u_uac1.o
 obj-$(CONFIG_USB_F_UAC1)	+= usb_f_uac1.o
+usb_f_uac1_acard-y		:= f_uac1_acard.o
+obj-$(CONFIG_USB_F_UAC1_ACARD)	+= usb_f_uac1_acard.o
 usb_f_uac2-y			:= f_uac2.o
 obj-$(CONFIG_USB_F_UAC2)	+= usb_f_uac2.o
 usb_f_uvc-y			:= f_uvc.o uvc_queue.o uvc_v4l2.o uvc_video.o uvc_configfs.o
diff --git a/drivers/usb/gadget/function/f_uac1_acard.c b/drivers/usb/gadget/function/f_uac1_acard.c
new file mode 100644
index 0000000..a329f94
--- /dev/null
+++ b/drivers/usb/gadget/function/f_uac1_acard.c
@@ -0,0 +1,803 @@
+/*
+ * f_uac1_acard.c -- USB Audio Class 1.0 Function (using u_audio API)
+ *
+ * Copyright (C) 2016 Ruslan Bilovol <ruslan.bilovol@gmail.com>
+ *
+ * This driver doesn't expect any real Audio codec to be present
+ * on the device - the audio streams are simply sinked to and
+ * sourced from a virtual ALSA sound card created.
+ *
+ * This file is based on f_uac1.c which is
+ *   Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
+ *   Copyright (C) 2008 Analog Devices, Inc
+ *
+ * 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.
+ */
+
+#include <linux/usb/audio.h>
+#include <linux/module.h>
+
+#include "u_audio.h"
+#include "u_uac1_acard.h"
+
+struct f_uac1 {
+	struct g_audio g_audio;
+	u8 ac_intf, as_in_intf, as_out_intf;
+	u8 ac_alt, as_in_alt, as_out_alt;	/* needed for get_alt() */
+};
+
+static inline struct f_uac1 *func_to_uac1(struct usb_function *f)
+{
+	return container_of(f, struct f_uac1, g_audio.func);
+}
+
+/*
+ * DESCRIPTORS ... most are static, but strings and full
+ * configuration descriptors are built on demand.
+ */
+
+/*
+ * We have three interfaces - one AudioControl and two AudioStreaming
+ *
+ * The driver implements a simple UAC_1 topology.
+ * USB-OUT -> IT_1 -> OT_2 -> ALSA_Capture
+ * ALSA_Playback -> IT_3 -> OT_4 -> USB-IN
+ */
+#define F_AUDIO_AC_INTERFACE		0
+#define F_AUDIO_AS_OUT_INTERFACE	1
+#define F_AUDIO_AS_IN_INTERFACE		2
+/* Number of streaming interfaces */
+#define F_AUDIO_NUM_INTERFACES		2
+
+/* B.3.1  Standard AC Interface Descriptor */
+static struct usb_interface_descriptor ac_interface_desc = {
+	.bLength =		USB_DT_INTERFACE_SIZE,
+	.bDescriptorType =	USB_DT_INTERFACE,
+	.bNumEndpoints =	0,
+	.bInterfaceClass =	USB_CLASS_AUDIO,
+	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOCONTROL,
+};
+
+/*
+ * The number of AudioStreaming and MIDIStreaming interfaces
+ * in the Audio Interface Collection
+ */
+DECLARE_UAC_AC_HEADER_DESCRIPTOR(2);
+
+#define UAC_DT_AC_HEADER_LENGTH	UAC_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
+/* 2 input terminals and 2 output terminals */
+#define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH \
+	+ 2*UAC_DT_INPUT_TERMINAL_SIZE + 2*UAC_DT_OUTPUT_TERMINAL_SIZE)
+/* B.3.2  Class-Specific AC Interface Descriptor */
+static struct uac1_ac_header_descriptor_2 ac_header_desc = {
+	.bLength =		UAC_DT_AC_HEADER_LENGTH,
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_HEADER,
+	.bcdADC =		cpu_to_le16(0x0100),
+	.wTotalLength =		cpu_to_le16(UAC_DT_TOTAL_LENGTH),
+	.bInCollection =	F_AUDIO_NUM_INTERFACES,
+	.baInterfaceNr = {
+	/* Interface number of the AudioStream interfaces */
+		[0] =		1,
+		[1] =		2,
+	}
+};
+
+#define USB_OUT_IT_ID	1
+static struct uac_input_terminal_descriptor usb_out_it_desc = {
+	.bLength =		UAC_DT_INPUT_TERMINAL_SIZE,
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_INPUT_TERMINAL,
+	.bTerminalID =		USB_OUT_IT_ID,
+	.wTerminalType =	UAC_TERMINAL_STREAMING,
+	.bAssocTerminal =	0,
+	.wChannelConfig =	0x3,
+};
+
+#define IO_OUT_OT_ID	2
+static struct uac1_output_terminal_descriptor io_out_ot_desc = {
+	.bLength		= UAC_DT_OUTPUT_TERMINAL_SIZE,
+	.bDescriptorType	= USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype	= UAC_OUTPUT_TERMINAL,
+	.bTerminalID		= IO_OUT_OT_ID,
+	.wTerminalType		= UAC_OUTPUT_TERMINAL_SPEAKER,
+	.bAssocTerminal		= 0,
+	.bSourceID		= USB_OUT_IT_ID,
+};
+
+#define IO_IN_IT_ID	3
+static struct uac_input_terminal_descriptor io_in_it_desc = {
+	.bLength		= UAC_DT_INPUT_TERMINAL_SIZE,
+	.bDescriptorType	= USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype	= UAC_INPUT_TERMINAL,
+	.bTerminalID		= IO_IN_IT_ID,
+	.wTerminalType		= UAC_INPUT_TERMINAL_MICROPHONE,
+	.bAssocTerminal		= 0,
+	.wChannelConfig		= 0x3,
+};
+
+#define USB_IN_OT_ID	4
+static struct uac1_output_terminal_descriptor usb_in_ot_desc = {
+	.bLength =		UAC_DT_OUTPUT_TERMINAL_SIZE,
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_OUTPUT_TERMINAL,
+	.bTerminalID =		USB_IN_OT_ID,
+	.wTerminalType =	UAC_TERMINAL_STREAMING,
+	.bAssocTerminal =	0,
+	.bSourceID =		IO_IN_IT_ID,
+};
+
+/* B.4.1  Standard AS Interface Descriptor */
+static struct usb_interface_descriptor as_out_interface_alt_0_desc = {
+	.bLength =		USB_DT_INTERFACE_SIZE,
+	.bDescriptorType =	USB_DT_INTERFACE,
+	.bAlternateSetting =	0,
+	.bNumEndpoints =	0,
+	.bInterfaceClass =	USB_CLASS_AUDIO,
+	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
+};
+
+static struct usb_interface_descriptor as_out_interface_alt_1_desc = {
+	.bLength =		USB_DT_INTERFACE_SIZE,
+	.bDescriptorType =	USB_DT_INTERFACE,
+	.bAlternateSetting =	1,
+	.bNumEndpoints =	1,
+	.bInterfaceClass =	USB_CLASS_AUDIO,
+	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
+};
+
+static struct usb_interface_descriptor as_in_interface_alt_0_desc = {
+	.bLength =		USB_DT_INTERFACE_SIZE,
+	.bDescriptorType =	USB_DT_INTERFACE,
+	.bAlternateSetting =	0,
+	.bNumEndpoints =	0,
+	.bInterfaceClass =	USB_CLASS_AUDIO,
+	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
+};
+
+static struct usb_interface_descriptor as_in_interface_alt_1_desc = {
+	.bLength =		USB_DT_INTERFACE_SIZE,
+	.bDescriptorType =	USB_DT_INTERFACE,
+	.bAlternateSetting =	1,
+	.bNumEndpoints =	1,
+	.bInterfaceClass =	USB_CLASS_AUDIO,
+	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
+};
+
+/* B.4.2  Class-Specific AS Interface Descriptor */
+static struct uac1_as_header_descriptor as_out_header_desc = {
+	.bLength =		UAC_DT_AS_HEADER_SIZE,
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_AS_GENERAL,
+	.bTerminalLink =	USB_OUT_IT_ID,
+	.bDelay =		1,
+	.wFormatTag =		UAC_FORMAT_TYPE_I_PCM,
+};
+
+static struct uac1_as_header_descriptor as_in_header_desc = {
+	.bLength =		UAC_DT_AS_HEADER_SIZE,
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_AS_GENERAL,
+	.bTerminalLink =	USB_IN_OT_ID,
+	.bDelay =		1,
+	.wFormatTag =		UAC_FORMAT_TYPE_I_PCM,
+};
+
+DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(1);
+
+static struct uac_format_type_i_discrete_descriptor_1 as_out_type_i_desc = {
+	.bLength =		UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_FORMAT_TYPE,
+	.bFormatType =		UAC_FORMAT_TYPE_I,
+	.bSubframeSize =	2,
+	.bBitResolution =	16,
+	.bSamFreqType =		1,
+};
+
+/* Standard ISO OUT Endpoint Descriptor */
+static struct usb_endpoint_descriptor as_out_ep_desc  = {
+	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress =	USB_DIR_OUT,
+	.bmAttributes =		USB_ENDPOINT_SYNC_ADAPTIVE
+				| USB_ENDPOINT_XFER_ISOC,
+	.wMaxPacketSize	=	cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
+	.bInterval =		4,
+};
+
+/* Class-specific AS ISO OUT Endpoint Descriptor */
+static struct uac_iso_endpoint_descriptor as_iso_out_desc = {
+	.bLength =		UAC_ISO_ENDPOINT_DESC_SIZE,
+	.bDescriptorType =	USB_DT_CS_ENDPOINT,
+	.bDescriptorSubtype =	UAC_EP_GENERAL,
+	.bmAttributes =		1,
+	.bLockDelayUnits =	1,
+	.wLockDelay =		cpu_to_le16(1),
+};
+
+static struct uac_format_type_i_discrete_descriptor_1 as_in_type_i_desc = {
+	.bLength =		UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
+	.bDescriptorType =	USB_DT_CS_INTERFACE,
+	.bDescriptorSubtype =	UAC_FORMAT_TYPE,
+	.bFormatType =		UAC_FORMAT_TYPE_I,
+	.bSubframeSize =	2,
+	.bBitResolution =	16,
+	.bSamFreqType =		1,
+};
+
+/* Standard ISO OUT Endpoint Descriptor */
+static struct usb_endpoint_descriptor as_in_ep_desc  = {
+	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
+	.bDescriptorType =	USB_DT_ENDPOINT,
+	.bEndpointAddress =	USB_DIR_IN,
+	.bmAttributes =		USB_ENDPOINT_SYNC_ASYNC
+				| USB_ENDPOINT_XFER_ISOC,
+	.wMaxPacketSize	=	cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
+	.bInterval =		4,
+};
+
+/* Class-specific AS ISO OUT Endpoint Descriptor */
+static struct uac_iso_endpoint_descriptor as_iso_in_desc = {
+	.bLength =		UAC_ISO_ENDPOINT_DESC_SIZE,
+	.bDescriptorType =	USB_DT_CS_ENDPOINT,
+	.bDescriptorSubtype =	UAC_EP_GENERAL,
+	.bmAttributes =		1,
+	.bLockDelayUnits =	0,
+	.wLockDelay =		0,
+};
+
+static struct usb_descriptor_header *f_audio_desc[] = {
+	(struct usb_descriptor_header *)&ac_interface_desc,
+	(struct usb_descriptor_header *)&ac_header_desc,
+
+	(struct usb_descriptor_header *)&usb_out_it_desc,
+	(struct usb_descriptor_header *)&io_out_ot_desc,
+	(struct usb_descriptor_header *)&io_in_it_desc,
+	(struct usb_descriptor_header *)&usb_in_ot_desc,
+
+	(struct usb_descriptor_header *)&as_out_interface_alt_0_desc,
+	(struct usb_descriptor_header *)&as_out_interface_alt_1_desc,
+	(struct usb_descriptor_header *)&as_out_header_desc,
+
+	(struct usb_descriptor_header *)&as_out_type_i_desc,
+
+	(struct usb_descriptor_header *)&as_out_ep_desc,
+	(struct usb_descriptor_header *)&as_iso_out_desc,
+
+	(struct usb_descriptor_header *)&as_in_interface_alt_0_desc,
+	(struct usb_descriptor_header *)&as_in_interface_alt_1_desc,
+	(struct usb_descriptor_header *)&as_in_header_desc,
+
+	(struct usb_descriptor_header *)&as_in_type_i_desc,
+
+	(struct usb_descriptor_header *)&as_in_ep_desc,
+	(struct usb_descriptor_header *)&as_iso_in_desc,
+	NULL,
+};
+
+enum {
+	STR_AC_IF,
+	STR_USB_OUT_IT,
+	STR_USB_OUT_IT_CH_NAMES,
+	STR_IO_OUT_OT,
+	STR_IO_IN_IT,
+	STR_IO_IN_IT_CH_NAMES,
+	STR_USB_IN_OT,
+	STR_AS_OUT_IF_ALT0,
+	STR_AS_OUT_IF_ALT1,
+	STR_AS_IN_IF_ALT0,
+	STR_AS_IN_IF_ALT1,
+};
+
+static struct usb_string strings_uac1[] = {
+	[STR_AC_IF].s = "AC Interface",
+	[STR_USB_OUT_IT].s = "Playback Input terminal",
+	[STR_USB_OUT_IT_CH_NAMES].s = "Playback Channels",
+	[STR_IO_OUT_OT].s = "Playback Output terminal",
+	[STR_IO_IN_IT].s = "Capture Input terminal",
+	[STR_IO_IN_IT_CH_NAMES].s = "Capture Channels",
+	[STR_USB_IN_OT].s = "Capture Output terminal",
+	[STR_AS_OUT_IF_ALT0].s = "Playback Inactive",
+	[STR_AS_OUT_IF_ALT1].s = "Playback Active",
+	[STR_AS_IN_IF_ALT0].s = "Capture Inactive",
+	[STR_AS_IN_IF_ALT1].s = "Capture Active",
+	{ },
+};
+
+static struct usb_gadget_strings str_uac1 = {
+	.language = 0x0409,	/* en-us */
+	.strings = strings_uac1,
+};
+
+static struct usb_gadget_strings *uac1_strings[] = {
+	&str_uac1,
+	NULL,
+};
+
+/*
+ * This function is an ALSA sound card following USB Audio Class Spec 1.0.
+ */
+
+static int audio_set_endpoint_req(struct usb_function *f,
+		const struct usb_ctrlrequest *ctrl)
+{
+	struct usb_composite_dev *cdev = f->config->cdev;
+	int			value = -EOPNOTSUPP;
+	u16			ep = le16_to_cpu(ctrl->wIndex);
+	u16			len = le16_to_cpu(ctrl->wLength);
+	u16			w_value = le16_to_cpu(ctrl->wValue);
+
+	DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
+			ctrl->bRequest, w_value, len, ep);
+
+	switch (ctrl->bRequest) {
+	case UAC_SET_CUR:
+		value = len;
+		break;
+
+	case UAC_SET_MIN:
+		break;
+
+	case UAC_SET_MAX:
+		break;
+
+	case UAC_SET_RES:
+		break;
+
+	case UAC_SET_MEM:
+		break;
+
+	default:
+		break;
+	}
+
+	return value;
+}
+
+static int audio_get_endpoint_req(struct usb_function *f,
+		const struct usb_ctrlrequest *ctrl)
+{
+	struct usb_composite_dev *cdev = f->config->cdev;
+	int value = -EOPNOTSUPP;
+	u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
+	u16 len = le16_to_cpu(ctrl->wLength);
+	u16 w_value = le16_to_cpu(ctrl->wValue);
+
+	DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
+			ctrl->bRequest, w_value, len, ep);
+
+	switch (ctrl->bRequest) {
+	case UAC_GET_CUR:
+	case UAC_GET_MIN:
+	case UAC_GET_MAX:
+	case UAC_GET_RES:
+		value = len;
+		break;
+	case UAC_GET_MEM:
+		break;
+	default:
+		break;
+	}
+
+	return value;
+}
+
+static int
+f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
+{
+	struct usb_composite_dev *cdev = f->config->cdev;
+	struct usb_request	*req = cdev->req;
+	int			value = -EOPNOTSUPP;
+	u16			w_index = le16_to_cpu(ctrl->wIndex);
+	u16			w_value = le16_to_cpu(ctrl->wValue);
+	u16			w_length = le16_to_cpu(ctrl->wLength);
+
+	/* composite driver infrastructure handles everything; interface
+	 * activation uses set_alt().
+	 */
+	switch (ctrl->bRequestType) {
+	case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
+		value = audio_set_endpoint_req(f, ctrl);
+		break;
+
+	case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
+		value = audio_get_endpoint_req(f, ctrl);
+		break;
+
+	default:
+		ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
+			ctrl->bRequestType, ctrl->bRequest,
+			w_value, w_index, w_length);
+	}
+
+	/* respond with data transfer or status phase? */
+	if (value >= 0) {
+		DBG(cdev, "audio req%02x.%02x v%04x i%04x l%d\n",
+			ctrl->bRequestType, ctrl->bRequest,
+			w_value, w_index, w_length);
+		req->zero = 0;
+		req->length = value;
+		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
+		if (value < 0)
+			ERROR(cdev, "audio response on err %d\n", value);
+	}
+
+	/* device either stalls (value < 0) or reports success */
+	return value;
+}
+
+static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
+{
+	struct usb_composite_dev *cdev = f->config->cdev;
+	struct usb_gadget *gadget = cdev->gadget;
+	struct device *dev = &gadget->dev;
+	struct f_uac1 *uac1 = func_to_uac1(f);
+	int ret = 0;
+
+	/* No i/f has more than 2 alt settings */
+	if (alt > 1) {
+		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
+		return -EINVAL;
+	}
+
+	if (intf == uac1->ac_intf) {
+		/* Control I/f has only 1 AltSetting - 0 */
+		if (alt) {
+			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
+			return -EINVAL;
+		}
+		return 0;
+	}
+
+	if (intf == uac1->as_out_intf) {
+		uac1->as_out_alt = alt;
+
+		if (alt)
+			ret = u_audio_start_capture(&uac1->g_audio);
+		else
+			u_audio_stop_capture(&uac1->g_audio);
+	} else if (intf == uac1->as_in_intf) {
+		uac1->as_in_alt = alt;
+
+			if (alt)
+				ret = u_audio_start_playback(&uac1->g_audio);
+			else
+				u_audio_stop_playback(&uac1->g_audio);
+	} else {
+		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
+		return -EINVAL;
+	}
+
+	return ret;
+}
+
+static int f_audio_get_alt(struct usb_function *f, unsigned intf)
+{
+	struct usb_composite_dev *cdev = f->config->cdev;
+	struct usb_gadget *gadget = cdev->gadget;
+	struct device *dev = &gadget->dev;
+	struct f_uac1 *uac1 = func_to_uac1(f);
+
+	if (intf == uac1->ac_intf)
+		return uac1->ac_alt;
+	else if (intf == uac1->as_out_intf)
+		return uac1->as_out_alt;
+	else if (intf == uac1->as_in_intf)
+		return uac1->as_in_alt;
+	else
+		dev_err(dev, "%s:%d Invalid Interface %d!\n",
+			__func__, __LINE__, intf);
+
+	return -EINVAL;
+}
+
+
+static void f_audio_disable(struct usb_function *f)
+{
+	struct f_uac1 *uac1 = func_to_uac1(f);
+
+	uac1->as_out_alt = 0;
+	uac1->as_in_alt = 0;
+
+	u_audio_stop_capture(&uac1->g_audio);
+}
+
+/*-------------------------------------------------------------------------*/
+
+/* audio function driver setup/binding */
+static int f_audio_bind(struct usb_configuration *c, struct usb_function *f)
+{
+	struct usb_composite_dev	*cdev = c->cdev;
+	struct usb_gadget		*gadget = cdev->gadget;
+	struct f_uac1			*uac1 = func_to_uac1(f);
+	struct g_audio			*audio = func_to_g_audio(f);
+	struct f_uac1_acard_opts	*audio_opts;
+	struct usb_ep			*ep = NULL;
+	struct usb_string		*us;
+	u8				*sam_freq;
+	int				rate;
+	int				status;
+
+	audio_opts = container_of(f->fi, struct f_uac1_acard_opts, func_inst);
+
+	us = usb_gstrings_attach(cdev, uac1_strings, ARRAY_SIZE(strings_uac1));
+	if (IS_ERR(us))
+		return PTR_ERR(us);
+	ac_interface_desc.iInterface = us[STR_AC_IF].id;
+	usb_out_it_desc.iTerminal = us[STR_USB_OUT_IT].id;
+	usb_out_it_desc.iChannelNames = us[STR_USB_OUT_IT_CH_NAMES].id;
+	io_out_ot_desc.iTerminal = us[STR_IO_OUT_OT].id;
+	as_out_interface_alt_0_desc.iInterface = us[STR_AS_OUT_IF_ALT0].id;
+	as_out_interface_alt_1_desc.iInterface = us[STR_AS_OUT_IF_ALT1].id;
+	io_in_it_desc.iTerminal = us[STR_IO_IN_IT].id;
+	io_in_it_desc.iChannelNames = us[STR_IO_IN_IT_CH_NAMES].id;
+	usb_in_ot_desc.iTerminal = us[STR_USB_IN_OT].id;
+	as_in_interface_alt_0_desc.iInterface = us[STR_AS_IN_IF_ALT0].id;
+	as_in_interface_alt_1_desc.iInterface = us[STR_AS_IN_IF_ALT1].id;
+
+	/* Set channel numbers */
+	usb_out_it_desc.bNrChannels = num_channels(audio_opts->c_chmask);
+	usb_out_it_desc.wChannelConfig = cpu_to_le16(audio_opts->c_chmask);
+	as_out_type_i_desc.bNrChannels = num_channels(audio_opts->c_chmask);
+	as_out_type_i_desc.bSubframeSize = audio_opts->c_ssize;
+	as_out_type_i_desc.bBitResolution = audio_opts->c_ssize * 8;
+	io_in_it_desc.bNrChannels = num_channels(audio_opts->p_chmask);
+	io_in_it_desc.wChannelConfig = cpu_to_le16(audio_opts->p_chmask);
+	as_in_type_i_desc.bNrChannels = num_channels(audio_opts->p_chmask);
+	as_in_type_i_desc.bSubframeSize = audio_opts->p_ssize;
+	as_in_type_i_desc.bBitResolution = audio_opts->p_ssize * 8;
+
+	/* Set sample rates */
+	rate = audio_opts->c_srate;
+	sam_freq = as_out_type_i_desc.tSamFreq[0];
+	memcpy(sam_freq, &rate, 3);
+	rate = audio_opts->p_srate;
+	sam_freq = as_in_type_i_desc.tSamFreq[0];
+	memcpy(sam_freq, &rate, 3);
+
+	/* allocate instance-specific interface IDs, and patch descriptors */
+	status = usb_interface_id(c, f);
+	if (status < 0)
+		goto fail;
+	ac_interface_desc.bInterfaceNumber = status;
+	uac1->ac_intf = status;
+	uac1->ac_alt = 0;
+
+	status = usb_interface_id(c, f);
+	if (status < 0)
+		goto fail;
+	as_out_interface_alt_0_desc.bInterfaceNumber = status;
+	as_out_interface_alt_1_desc.bInterfaceNumber = status;
+	uac1->as_out_intf = status;
+	uac1->as_out_alt = 0;
+
+	status = usb_interface_id(c, f);
+	if (status < 0)
+		goto fail;
+	as_in_interface_alt_0_desc.bInterfaceNumber = status;
+	as_in_interface_alt_1_desc.bInterfaceNumber = status;
+	uac1->as_in_intf = status;
+	uac1->as_in_alt = 0;
+
+	audio->gadget = gadget;
+
+	status = -ENODEV;
+
+	/* allocate instance-specific endpoints */
+	ep = usb_ep_autoconfig(cdev->gadget, &as_out_ep_desc);
+	if (!ep)
+		goto fail;
+	audio->out_ep = ep;
+	audio->out_ep->desc = &as_out_ep_desc;
+
+	ep = usb_ep_autoconfig(cdev->gadget, &as_in_ep_desc);
+	if (!ep)
+		goto fail;
+	audio->in_ep = ep;
+	audio->in_ep->desc = &as_in_ep_desc;
+
+	/* copy descriptors, and track endpoint copies */
+	status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, NULL,
+					NULL);
+	if (status)
+		goto fail;
+
+	audio->out_ep_maxpsize = as_out_ep_desc.wMaxPacketSize;
+	audio->in_ep_maxpsize = as_in_ep_desc.wMaxPacketSize;
+	audio->params.c_chmask = audio_opts->c_chmask;
+	audio->params.c_srate = audio_opts->c_srate;
+	audio->params.c_ssize = audio_opts->c_ssize;
+	audio->params.p_chmask = audio_opts->p_chmask;
+	audio->params.p_srate = audio_opts->p_srate;
+	audio->params.p_ssize = audio_opts->p_ssize;
+	audio->params.req_number = audio_opts->req_number;
+
+	status = g_audio_setup(audio, "UAC1_PCM", "UAC1_Gadget");
+	if (status)
+		goto err_card_register;
+
+	return 0;
+
+err_card_register:
+	usb_free_all_descriptors(f);
+fail:
+	return status;
+}
+
+/*-------------------------------------------------------------------------*/
+
+static inline struct
+f_uac1_acard_opts *to_f_uac1_acard_opts(struct config_item *item)
+{
+	return container_of(to_config_group(item), struct f_uac1_acard_opts,
+			    func_inst.group);
+}
+
+static void f_uac1_attr_release(struct config_item *item)
+{
+	struct f_uac1_acard_opts *opts = to_f_uac1_acard_opts(item);
+
+	usb_put_function_instance(&opts->func_inst);
+}
+
+static struct configfs_item_operations f_uac1_item_ops = {
+	.release	= f_uac1_attr_release,
+};
+
+#define UAC1_ATTRIBUTE(name)						\
+static ssize_t f_uac1_acard_opts_##name##_show(			\
+					  struct config_item *item,	\
+					  char *page)			\
+{									\
+	struct f_uac1_acard_opts *opts = to_f_uac1_acard_opts(item);	\
+	int result;							\
+									\
+	mutex_lock(&opts->lock);					\
+	result = sprintf(page, "%u\n", opts->name);			\
+	mutex_unlock(&opts->lock);					\
+									\
+	return result;							\
+}									\
+									\
+static ssize_t f_uac1_acard_opts_##name##_store(			\
+					  struct config_item *item,	\
+					  const char *page, size_t len)	\
+{									\
+	struct f_uac1_acard_opts *opts = to_f_uac1_acard_opts(item);	\
+	int ret;							\
+	u32 num;							\
+									\
+	mutex_lock(&opts->lock);					\
+	if (opts->refcnt) {						\
+		ret = -EBUSY;						\
+		goto end;						\
+	}								\
+									\
+	ret = kstrtou32(page, 0, &num);					\
+	if (ret)							\
+		goto end;						\
+									\
+	opts->name = num;						\
+	ret = len;							\
+									\
+end:									\
+	mutex_unlock(&opts->lock);					\
+	return ret;							\
+}									\
+									\
+CONFIGFS_ATTR(f_uac1_acard_opts_, name)
+
+UAC1_ATTRIBUTE(c_chmask);
+UAC1_ATTRIBUTE(c_srate);
+UAC1_ATTRIBUTE(c_ssize);
+UAC1_ATTRIBUTE(p_chmask);
+UAC1_ATTRIBUTE(p_srate);
+UAC1_ATTRIBUTE(p_ssize);
+UAC1_ATTRIBUTE(req_number);
+
+static struct configfs_attribute *f_uac1_attrs[] = {
+	&f_uac1_acard_opts_attr_c_chmask,
+	&f_uac1_acard_opts_attr_c_srate,
+	&f_uac1_acard_opts_attr_c_ssize,
+	&f_uac1_acard_opts_attr_p_chmask,
+	&f_uac1_acard_opts_attr_p_srate,
+	&f_uac1_acard_opts_attr_p_ssize,
+	&f_uac1_acard_opts_attr_req_number,
+	NULL,
+};
+
+static struct config_item_type f_uac1_func_type = {
+	.ct_item_ops	= &f_uac1_item_ops,
+	.ct_attrs	= f_uac1_attrs,
+	.ct_owner	= THIS_MODULE,
+};
+
+static void f_audio_free_inst(struct usb_function_instance *f)
+{
+	struct f_uac1_acard_opts *opts;
+
+	opts = container_of(f, struct f_uac1_acard_opts, func_inst);
+	kfree(opts);
+}
+
+static struct usb_function_instance *f_audio_alloc_inst(void)
+{
+	struct f_uac1_acard_opts *opts;
+
+	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
+	if (!opts)
+		return ERR_PTR(-ENOMEM);
+
+	mutex_init(&opts->lock);
+	opts->func_inst.free_func_inst = f_audio_free_inst;
+
+	config_group_init_type_name(&opts->func_inst.group, "",
+				    &f_uac1_func_type);
+
+	opts->c_chmask = UAC1_DEF_CCHMASK;
+	opts->c_srate = UAC1_DEF_CSRATE;
+	opts->c_ssize = UAC1_DEF_CSSIZE;
+	opts->p_chmask = UAC1_DEF_PCHMASK;
+	opts->p_srate = UAC1_DEF_PSRATE;
+	opts->p_ssize = UAC1_DEF_PSSIZE;
+	opts->req_number = UAC1_DEF_REQ_NUM;
+	return &opts->func_inst;
+}
+
+static void f_audio_free(struct usb_function *f)
+{
+	struct g_audio *audio;
+	struct f_uac1_acard_opts *opts;
+
+	audio = func_to_g_audio(f);
+	opts = container_of(f->fi, struct f_uac1_acard_opts, func_inst);
+	kfree(audio);
+	mutex_lock(&opts->lock);
+	--opts->refcnt;
+	mutex_unlock(&opts->lock);
+}
+
+static void f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
+{
+	struct g_audio *audio = func_to_g_audio(f);
+
+	g_audio_cleanup(audio);
+	usb_free_all_descriptors(f);
+
+	audio->gadget = NULL;
+}
+
+static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
+{
+	struct f_uac1 *uac1;
+	struct f_uac1_acard_opts *opts;
+
+	/* allocate and initialize one new instance */
+	uac1 = kzalloc(sizeof(*uac1), GFP_KERNEL);
+	if (!uac1)
+		return ERR_PTR(-ENOMEM);
+
+	opts = container_of(fi, struct f_uac1_acard_opts, func_inst);
+	mutex_lock(&opts->lock);
+	++opts->refcnt;
+	mutex_unlock(&opts->lock);
+
+	uac1->g_audio.func.name = "uac1_acard_func";
+	uac1->g_audio.func.bind = f_audio_bind;
+	uac1->g_audio.func.unbind = f_audio_unbind;
+	uac1->g_audio.func.set_alt = f_audio_set_alt;
+	uac1->g_audio.func.get_alt = f_audio_get_alt;
+	uac1->g_audio.func.setup = f_audio_setup;
+	uac1->g_audio.func.disable = f_audio_disable;
+	uac1->g_audio.func.free_func = f_audio_free;
+
+	return &uac1->g_audio.func;
+}
+
+DECLARE_USB_FUNCTION_INIT(uac1_acard, f_audio_alloc_inst, f_audio_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ruslan Bilovol");
diff --git a/drivers/usb/gadget/function/u_uac1_acard.h b/drivers/usb/gadget/function/u_uac1_acard.h
new file mode 100644
index 0000000..c172687
--- /dev/null
+++ b/drivers/usb/gadget/function/u_uac1_acard.h
@@ -0,0 +1,41 @@
+/*
+ * u_uac1_acard.h - Utility definitions for UAC1 function
+ *
+ * Copyright (C) 2016 Ruslan Bilovol <ruslan.bilovol@gmail.com>
+ *
+ * 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.
+ */
+
+#ifndef __U_UAC1_ACARD_H
+#define __U_UAC1_ACARD_H
+
+#include <linux/usb/composite.h>
+
+#define UAC1_OUT_EP_MAX_PACKET_SIZE	200
+#define UAC1_DEF_CCHMASK	0x3
+#define UAC1_DEF_CSRATE		48000
+#define UAC1_DEF_CSSIZE		2
+#define UAC1_DEF_PCHMASK	0x3
+#define UAC1_DEF_PSRATE		48000
+#define UAC1_DEF_PSSIZE		2
+#define UAC1_DEF_REQ_NUM	2
+
+
+struct f_uac1_acard_opts {
+	struct usb_function_instance	func_inst;
+	int				c_chmask;
+	int				c_srate;
+	int				c_ssize;
+	int				p_chmask;
+	int				p_srate;
+	int				p_ssize;
+	int				req_number;
+	unsigned			bound:1;
+
+	struct mutex			lock;
+	int				refcnt;
+};
+
+#endif /* __U_UAC1_ACARD_H */
diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
index 5344064..4d0b6b5 100644
--- a/drivers/usb/gadget/legacy/Kconfig
+++ b/drivers/usb/gadget/legacy/Kconfig
@@ -54,9 +54,10 @@ config USB_AUDIO
 	depends on SND
 	select USB_LIBCOMPOSITE
 	select SND_PCM
-	select USB_F_UAC1 if GADGET_UAC1
+	select USB_F_UAC1 if (GADGET_UAC1 && !GADGET_UAC1_ACARD)
+	select USB_F_UAC1_ACARD if (GADGET_UAC1 && GADGET_UAC1_ACARD)
 	select USB_F_UAC2 if !GADGET_UAC1
-	select USB_U_AUDIO if USB_F_UAC2
+	select USB_U_AUDIO if (USB_F_UAC2 || USB_F_UAC1_ACARD)
 	help
 	  This Gadget Audio driver is compatible with USB Audio Class
 	  specification 2.0. It implements 1 AudioControl interface,
@@ -81,6 +82,16 @@ config GADGET_UAC1
 	  paths hardwired to the Audio codec chip on-board and doesn't work
 	  without one.
 
+config GADGET_UAC1_ACARD
+	bool "Virtual ALSA Card for UAC 1.0 driver"
+	depends on GADGET_UAC1
+	help
+	  This is an alternative UAC Spec-1.0 driver implementation
+	  that uses new API (u_audio), and doesn't expect any real
+	  audio codec to be present on the device. The audio streams
+	  are simply sinked to and sourced from a virtual ALSA sound
+	  card created
+
 config USB_ETH
 	tristate "Ethernet Gadget (with CDC Ethernet support)"
 	depends on NET
diff --git a/drivers/usb/gadget/legacy/audio.c b/drivers/usb/gadget/legacy/audio.c
index 8a39f42..6de194a 100644
--- a/drivers/usb/gadget/legacy/audio.c
+++ b/drivers/usb/gadget/legacy/audio.c
@@ -53,6 +53,39 @@
 module_param(c_ssize, uint, S_IRUGO);
 MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)");
 #else
+#ifdef CONFIG_GADGET_UAC1_ACARD
+#include "u_uac1_acard.h"
+
+/* Playback(USB-IN) Default Stereo - Fl/Fr */
+static int p_chmask = UAC1_DEF_PCHMASK;
+module_param(p_chmask, uint, S_IRUGO);
+MODULE_PARM_DESC(p_chmask, "Playback Channel Mask");
+
+/* Playback Default 48 KHz */
+static int p_srate = UAC1_DEF_PSRATE;
+module_param(p_srate, uint, S_IRUGO);
+MODULE_PARM_DESC(p_srate, "Playback Sampling Rate");
+
+/* Playback Default 16bits/sample */
+static int p_ssize = UAC1_DEF_PSSIZE;
+module_param(p_ssize, uint, S_IRUGO);
+MODULE_PARM_DESC(p_ssize, "Playback Sample Size(bytes)");
+
+/* Capture(USB-OUT) Default Stereo - Fl/Fr */
+static int c_chmask = UAC1_DEF_CCHMASK;
+module_param(c_chmask, uint, S_IRUGO);
+MODULE_PARM_DESC(c_chmask, "Capture Channel Mask");
+
+/* Capture Default 48 KHz */
+static int c_srate = UAC1_DEF_CSRATE;
+module_param(c_srate, uint, S_IRUGO);
+MODULE_PARM_DESC(c_srate, "Capture Sampling Rate");
+
+/* Capture Default 16bits/sample */
+static int c_ssize = UAC1_DEF_CSSIZE;
+module_param(c_ssize, uint, S_IRUGO);
+MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)");
+#else /* CONFIG_GADGET_UAC1_ACARD */
 #include "u_uac1.h"
 
 static char *fn_play = FILE_PCM_PLAYBACK;
@@ -78,6 +111,7 @@
 static int audio_buf_size = UAC1_AUDIO_BUF_SIZE;
 module_param(audio_buf_size, int, S_IRUGO);
 MODULE_PARM_DESC(audio_buf_size, "Audio buffer size");
+#endif /* CONFIG_GADGET_UAC1_ACARD */
 #endif
 
 /* string IDs are assigned dynamically */
@@ -207,8 +241,12 @@ static int audio_bind(struct usb_composite_dev *cdev)
 #ifndef CONFIG_GADGET_UAC1
 	struct f_uac2_opts	*uac2_opts;
 #else
+#ifdef CONFIG_GADGET_UAC1_ACARD
+	struct f_uac1_acard_opts	*uac1_opts;
+#else
 	struct f_uac1_opts	*uac1_opts;
 #endif
+#endif
 	int			status;
 
 #ifndef CONFIG_GADGET_UAC1
@@ -216,7 +254,11 @@ static int audio_bind(struct usb_composite_dev *cdev)
 	if (IS_ERR(fi_uac2))
 		return PTR_ERR(fi_uac2);
 #else
+#ifdef CONFIG_GADGET_UAC1_ACARD
+	fi_uac1 = usb_get_function_instance("uac1_acard");
+#else
 	fi_uac1 = usb_get_function_instance("uac1");
+#endif
 	if (IS_ERR(fi_uac1))
 		return PTR_ERR(fi_uac1);
 #endif
@@ -231,6 +273,16 @@ static int audio_bind(struct usb_composite_dev *cdev)
 	uac2_opts->c_ssize = c_ssize;
 	uac2_opts->req_number = UAC2_DEF_REQ_NUM;
 #else
+#ifdef CONFIG_GADGET_UAC1_ACARD
+	uac1_opts = container_of(fi_uac1, struct f_uac1_acard_opts, func_inst);
+	uac1_opts->p_chmask = p_chmask;
+	uac1_opts->p_srate = p_srate;
+	uac1_opts->p_ssize = p_ssize;
+	uac1_opts->c_chmask = c_chmask;
+	uac1_opts->c_srate = c_srate;
+	uac1_opts->c_ssize = c_ssize;
+	uac1_opts->req_number = UAC1_DEF_REQ_NUM;
+#else /* CONFIG_GADGET_UAC1_ACARD */
 	uac1_opts = container_of(fi_uac1, struct f_uac1_opts, func_inst);
 	uac1_opts->fn_play = fn_play;
 	uac1_opts->fn_cap = fn_cap;
@@ -238,6 +290,7 @@ static int audio_bind(struct usb_composite_dev *cdev)
 	uac1_opts->req_buf_size = req_buf_size;
 	uac1_opts->req_count = req_count;
 	uac1_opts->audio_buf_size = audio_buf_size;
+#endif /* CONFIG_GADGET_UAC1_ACARD */
 #endif
 
 	status = usb_string_ids_tab(cdev, strings_dev);
-- 
1.9.1

^ permalink raw reply related	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core
  2017-05-17 22:37 ` [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core Ruslan Bilovol
@ 2017-05-22 15:58   ` Jassi Brar
  2017-05-29 23:43     ` Ruslan Bilovol
  2017-06-02  9:34   ` Felipe Balbi
  1 sibling, 1 reply; 17+ messages in thread
From: Jassi Brar @ 2017-05-22 15:58 UTC (permalink / raw)
  To: Ruslan Bilovol
  Cc: Felipe Balbi, Daniel Mack, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, Linux Kernel Mailing List

On Thu, May 18, 2017 at 4:07 AM, Ruslan Bilovol
<ruslan.bilovol@gmail.com> wrote:
> Abstract the peripheral side ALSA sound card code from
> the f_uac2 function into a component that can be called
> by various functions, so the various flavors can be split
> apart and selectively reused.
>
> Visible changes:
>  - add uac_params structure to pass audio paramteres for
>    g_audio_setup
>  - make ALSA sound card's name configurable
>  - add [in/out]_ep_maxpsize
>  - allocate snd_uac_chip structure during g_audio_setup
>  - add u_audio_[start/stop]_[capture/playback] functions
>
> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
> ---
>  drivers/usb/gadget/Kconfig            |   4 +
>  drivers/usb/gadget/function/Makefile  |   1 +
>  drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------
>  drivers/usb/gadget/function/u_audio.c | 661 +++++++++++++++++++++++++++++++
>  drivers/usb/gadget/function/u_audio.h |  95 +++++
>  drivers/usb/gadget/legacy/Kconfig     |   1 +
>  6 files changed, 846 insertions(+), 637 deletions(-)
>  create mode 100644 drivers/usb/gadget/function/u_audio.c
>  create mode 100644 drivers/usb/gadget/function/u_audio.h
>
> diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
> index c164d6b..2ba0ace 100644
> --- a/drivers/usb/gadget/Kconfig
> +++ b/drivers/usb/gadget/Kconfig
> @@ -158,6 +158,9 @@ config USB_U_SERIAL
>  config USB_U_ETHER
>         tristate
>
> +config USB_U_AUDIO
> +       tristate
> +
>  config USB_F_SERIAL
>         tristate
>
> @@ -381,6 +384,7 @@ config USB_CONFIGFS_F_UAC2
>         depends on SND
>         select USB_LIBCOMPOSITE
>         select SND_PCM
> +       select USB_U_AUDIO
>         select USB_F_UAC2
>         help
>           This Audio function is compatible with USB Audio Class
> diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
> index cb8c225..b29f2ae 100644
> --- a/drivers/usb/gadget/function/Makefile
> +++ b/drivers/usb/gadget/function/Makefile
> @@ -32,6 +32,7 @@ usb_f_mass_storage-y          := f_mass_storage.o storage_common.o
>  obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o
>  usb_f_fs-y                     := f_fs.o
>  obj-$(CONFIG_USB_F_FS)         += usb_f_fs.o
> +obj-$(CONFIG_USB_U_AUDIO)      += u_audio.o
>  usb_f_uac1-y                   := f_uac1.o u_uac1.o
>  obj-$(CONFIG_USB_F_UAC1)       += usb_f_uac1.o
>  usb_f_uac2-y                   := f_uac2.o
> diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c
> index d4565b5..059a14a 100644
> --- a/drivers/usb/gadget/function/f_uac2.c
> +++ b/drivers/usb/gadget/function/f_uac2.c
> @@ -15,10 +15,7 @@
>  #include <linux/usb/audio-v2.h>
>  #include <linux/module.h>
>
> -#include <sound/core.h>
> -#include <sound/pcm.h>
> -#include <sound/pcm_params.h>
> -
> +#include "u_audio.h"
>  #include "u_uac2.h"
>
>  /*
> @@ -50,455 +47,23 @@
>  #define UNFLW_CTRL     8
>  #define OVFLW_CTRL     10
>
> -struct uac2_req {
> -       struct uac2_rtd_params *pp; /* parent param */
> -       struct usb_request *req;
> -};
> -
> -struct uac2_rtd_params {
> -       struct snd_uac2_chip *uac2; /* parent chip */
> -       bool ep_enabled; /* if the ep is enabled */
> -       /* Size of the ring buffer */
> -       size_t dma_bytes;
> -       unsigned char *dma_area;
> -
> -       struct snd_pcm_substream *ss;
> -
> -       /* Ring buffer */
> -       ssize_t hw_ptr;
> -
> -       void *rbuf;
> -
> -       size_t period_size;
> -
> -       unsigned max_psize;
> -       struct uac2_req *ureq;
> -
> -       spinlock_t lock;
> -};
> -
> -struct snd_uac2_chip {
> -       struct uac2_rtd_params p_prm;
> -       struct uac2_rtd_params c_prm;
> -
> -       struct snd_card *card;
> -       struct snd_pcm *pcm;
> -
> -       /* timekeeping for the playback endpoint */
> -       unsigned int p_interval;
> -       unsigned int p_residue;
> -
> -       /* pre-calculated values for playback iso completion */
> -       unsigned int p_pktsize;
> -       unsigned int p_pktsize_residue;
> -       unsigned int p_framesize;
> +struct f_uac2 {
> +       struct g_audio g_audio;
> +       u8 ac_intf, as_in_intf, as_out_intf;
> +       u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
>  };
>
> -#define BUFF_SIZE_MAX  (PAGE_SIZE * 16)
> -#define PRD_SIZE_MAX   PAGE_SIZE
> -#define MIN_PERIODS    4
> -
> -static struct snd_pcm_hardware uac2_pcm_hardware = {
> -       .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
> -                | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
> -                | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
> -       .rates = SNDRV_PCM_RATE_CONTINUOUS,
> -       .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
> -       .buffer_bytes_max = BUFF_SIZE_MAX,
> -       .period_bytes_max = PRD_SIZE_MAX,
> -       .periods_min = MIN_PERIODS,
> -};
> -
> -struct audio_dev {
> -       u8 ac_intf, ac_alt;
> -       u8 as_out_intf, as_out_alt;
> -       u8 as_in_intf, as_in_alt;
> -
> -       struct usb_ep *in_ep, *out_ep;
> -       struct usb_function func;
> -       struct usb_gadget *gadget;
> -
> -       /* The ALSA Sound Card it represents on the USB-Client side */
> -       struct snd_uac2_chip uac2;
> -};
> -
> -static inline
> -struct audio_dev *func_to_agdev(struct usb_function *f)
> +static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
>  {
> -       return container_of(f, struct audio_dev, func);
> +       return container_of(f, struct f_uac2, g_audio.func);
>  }
>
>  static inline
> -struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
> -{
> -       return container_of(u, struct audio_dev, uac2);
> -}
> -
> -static inline
> -struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
> +struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
>  {
>         return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
>  }
>
> -static inline
> -uint num_channels(uint chanmask)
> -{
> -       uint num = 0;
> -
> -       while (chanmask) {
> -               num += (chanmask & 1);
> -               chanmask >>= 1;
> -       }
> -
> -       return num;
> -}
> -
> -static void
> -agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
> -{
> -       unsigned pending;
> -       unsigned long flags;
> -       unsigned int hw_ptr;
> -       bool update_alsa = false;
> -       int status = req->status;
> -       struct uac2_req *ur = req->context;
> -       struct snd_pcm_substream *substream;
> -       struct uac2_rtd_params *prm = ur->pp;
> -       struct snd_uac2_chip *uac2 = prm->uac2;
> -
> -       /* i/f shutting down */
> -       if (!prm->ep_enabled || req->status == -ESHUTDOWN)
> -               return;
> -
> -       /*
> -        * We can't really do much about bad xfers.
> -        * Afterall, the ISOCH xfers could fail legitimately.
> -        */
> -       if (status)
> -               pr_debug("%s: iso_complete status(%d) %d/%d\n",
> -                       __func__, status, req->actual, req->length);
> -
> -       substream = prm->ss;
> -
> -       /* Do nothing if ALSA isn't active */
> -       if (!substream)
> -               goto exit;
> -
> -       spin_lock_irqsave(&prm->lock, flags);
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> -               /*
> -                * For each IN packet, take the quotient of the current data
> -                * rate and the endpoint's interval as the base packet size.
> -                * If there is a residue from this division, add it to the
> -                * residue accumulator.
> -                */
> -               req->length = uac2->p_pktsize;
> -               uac2->p_residue += uac2->p_pktsize_residue;
> -
> -               /*
> -                * Whenever there are more bytes in the accumulator than we
> -                * need to add one more sample frame, increase this packet's
> -                * size and decrease the accumulator.
> -                */
> -               if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
> -                       req->length += uac2->p_framesize;
> -                       uac2->p_residue -= uac2->p_framesize *
> -                                          uac2->p_interval;
> -               }
> -
> -               req->actual = req->length;
> -       }
> -
> -       pending = prm->hw_ptr % prm->period_size;
> -       pending += req->actual;
> -       if (pending >= prm->period_size)
> -               update_alsa = true;
> -
> -       hw_ptr = prm->hw_ptr;
> -       prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
> -
> -       spin_unlock_irqrestore(&prm->lock, flags);
> -
> -       /* Pack USB load in ALSA ring buffer */
> -       pending = prm->dma_bytes - hw_ptr;
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> -               if (unlikely(pending < req->actual)) {
> -                       memcpy(req->buf, prm->dma_area + hw_ptr, pending);
> -                       memcpy(req->buf + pending, prm->dma_area,
> -                              req->actual - pending);
> -               } else {
> -                       memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
> -               }
> -       } else {
> -               if (unlikely(pending < req->actual)) {
> -                       memcpy(prm->dma_area + hw_ptr, req->buf, pending);
> -                       memcpy(prm->dma_area, req->buf + pending,
> -                              req->actual - pending);
> -               } else {
> -                       memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
> -               }
> -       }
> -
> -exit:
> -       if (usb_ep_queue(ep, req, GFP_ATOMIC))
> -               dev_err(uac2->card->dev, "%d Error!\n", __LINE__);
> -
> -       if (update_alsa)
> -               snd_pcm_period_elapsed(substream);
> -
> -       return;
> -}
> -
> -static int
> -uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
> -{
> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
> -       struct audio_dev *agdev = uac2_to_agdev(uac2);
> -       struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
> -       struct uac2_rtd_params *prm;
> -       unsigned long flags;
> -       int err = 0;
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> -               prm = &uac2->p_prm;
> -       else
> -               prm = &uac2->c_prm;
> -
> -       spin_lock_irqsave(&prm->lock, flags);
> -
> -       /* Reset */
> -       prm->hw_ptr = 0;
> -
> -       switch (cmd) {
> -       case SNDRV_PCM_TRIGGER_START:
> -       case SNDRV_PCM_TRIGGER_RESUME:
> -               prm->ss = substream;
> -               break;
> -       case SNDRV_PCM_TRIGGER_STOP:
> -       case SNDRV_PCM_TRIGGER_SUSPEND:
> -               prm->ss = NULL;
> -               break;
> -       default:
> -               err = -EINVAL;
> -       }
> -
> -       spin_unlock_irqrestore(&prm->lock, flags);
> -
> -       /* Clear buffer after Play stops */
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
> -               memset(prm->rbuf, 0, prm->max_psize * uac2_opts->req_number);
> -
> -       return err;
> -}
> -
> -static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
> -{
> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
> -       struct uac2_rtd_params *prm;
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> -               prm = &uac2->p_prm;
> -       else
> -               prm = &uac2->c_prm;
> -
> -       return bytes_to_frames(substream->runtime, prm->hw_ptr);
> -}
> -
> -static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
> -                              struct snd_pcm_hw_params *hw_params)
> -{
> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
> -       struct uac2_rtd_params *prm;
> -       int err;
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> -               prm = &uac2->p_prm;
> -       else
> -               prm = &uac2->c_prm;
> -
> -       err = snd_pcm_lib_malloc_pages(substream,
> -                                       params_buffer_bytes(hw_params));
> -       if (err >= 0) {
> -               prm->dma_bytes = substream->runtime->dma_bytes;
> -               prm->dma_area = substream->runtime->dma_area;
> -               prm->period_size = params_period_bytes(hw_params);
> -       }
> -
> -       return err;
> -}
> -
> -static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
> -{
> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
> -       struct uac2_rtd_params *prm;
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> -               prm = &uac2->p_prm;
> -       else
> -               prm = &uac2->c_prm;
> -
> -       prm->dma_area = NULL;
> -       prm->dma_bytes = 0;
> -       prm->period_size = 0;
> -
> -       return snd_pcm_lib_free_pages(substream);
> -}
> -
> -static int uac2_pcm_open(struct snd_pcm_substream *substream)
> -{
> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
> -       struct snd_pcm_runtime *runtime = substream->runtime;
> -       struct audio_dev *audio_dev;
> -       struct f_uac2_opts *opts;
> -       int p_ssize, c_ssize;
> -       int p_srate, c_srate;
> -       int p_chmask, c_chmask;
> -
> -       audio_dev = uac2_to_agdev(uac2);
> -       opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
> -       p_ssize = opts->p_ssize;
> -       c_ssize = opts->c_ssize;
> -       p_srate = opts->p_srate;
> -       c_srate = opts->c_srate;
> -       p_chmask = opts->p_chmask;
> -       c_chmask = opts->c_chmask;
> -       uac2->p_residue = 0;
> -
> -       runtime->hw = uac2_pcm_hardware;
> -
> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> -               spin_lock_init(&uac2->p_prm.lock);
> -               runtime->hw.rate_min = p_srate;
> -               switch (p_ssize) {
> -               case 3:
> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
> -                       break;
> -               case 4:
> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
> -                       break;
> -               default:
> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
> -                       break;
> -               }
> -               runtime->hw.channels_min = num_channels(p_chmask);
> -               runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
> -                                               / runtime->hw.periods_min;
> -       } else {
> -               spin_lock_init(&uac2->c_prm.lock);
> -               runtime->hw.rate_min = c_srate;
> -               switch (c_ssize) {
> -               case 3:
> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
> -                       break;
> -               case 4:
> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
> -                       break;
> -               default:
> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
> -                       break;
> -               }
> -               runtime->hw.channels_min = num_channels(c_chmask);
> -               runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
> -                                               / runtime->hw.periods_min;
> -       }
> -
> -       runtime->hw.rate_max = runtime->hw.rate_min;
> -       runtime->hw.channels_max = runtime->hw.channels_min;
> -
> -       snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
> -
> -       return 0;
> -}
> -
> -/* ALSA cries without these function pointers */
> -static int uac2_pcm_null(struct snd_pcm_substream *substream)
> -{
> -       return 0;
> -}
> -
> -static struct snd_pcm_ops uac2_pcm_ops = {
> -       .open = uac2_pcm_open,
> -       .close = uac2_pcm_null,
> -       .ioctl = snd_pcm_lib_ioctl,
> -       .hw_params = uac2_pcm_hw_params,
> -       .hw_free = uac2_pcm_hw_free,
> -       .trigger = uac2_pcm_trigger,
> -       .pointer = uac2_pcm_pointer,
> -       .prepare = uac2_pcm_null,
> -};
> -
> -static int snd_uac2_probe(struct audio_dev *audio_dev)
> -{
> -       struct snd_uac2_chip *uac2 = &audio_dev->uac2;
> -       struct snd_card *card;
> -       struct snd_pcm *pcm;
> -       struct f_uac2_opts *opts;
> -       int err;
> -       int p_chmask, c_chmask;
> -
> -       opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
> -       p_chmask = opts->p_chmask;
> -       c_chmask = opts->c_chmask;
> -
> -       /* Choose any slot, with no id */
> -       err = snd_card_new(&audio_dev->gadget->dev,
> -                       -1, NULL, THIS_MODULE, 0, &card);
> -       if (err < 0)
> -               return err;
> -
> -       uac2->card = card;
> -
> -       /*
> -        * Create first PCM device
> -        * Create a substream only for non-zero channel streams
> -        */
> -       err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
> -                              p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
> -       if (err < 0)
> -               goto snd_fail;
> -
> -       strcpy(pcm->name, "UAC2 PCM");
> -       pcm->private_data = uac2;
> -
> -       uac2->pcm = pcm;
> -
> -       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
> -       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
> -
> -       strcpy(card->driver, "UAC2_Gadget");
> -       strcpy(card->shortname, "UAC2_Gadget");
> -       sprintf(card->longname, "UAC2_Gadget %i", card->dev->id);
> -
> -       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
> -               snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
> -
> -       err = snd_card_register(card);
> -
> -       if (!err)
> -               return 0;
> -
> -snd_fail:
> -       snd_card_free(card);
> -
> -       uac2->pcm = NULL;
> -       uac2->card = NULL;
> -
> -       return err;
> -}
> -
> -static int snd_uac2_remove(struct audio_dev *audio_dev)
> -{
> -       struct snd_card *card = audio_dev->uac2.card;
> -
> -       if (card)
> -               return snd_card_free(card);
> -
> -       return 0;
> -}
> -
> -
>  /* --------- USB Function Interface ------------- */
>
>  enum {
> @@ -886,32 +451,6 @@ struct cntrl_range_lay3 {
>         __u32   dRES;
>  } __packed;
>
> -static inline void
> -free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
> -{
> -       struct snd_uac2_chip *uac2 = prm->uac2;
> -       struct audio_dev *agdev = uac2_to_agdev(uac2);
> -       struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
> -       int i;
> -
> -       if (!prm->ep_enabled)
> -               return;
> -
> -       prm->ep_enabled = false;
> -
> -       for (i = 0; i < uac2_opts->req_number; i++) {
> -               if (prm->ureq[i].req) {
> -                       usb_ep_dequeue(ep, prm->ureq[i].req);
> -                       usb_ep_free_request(ep, prm->ureq[i].req);
> -                       prm->ureq[i].req = NULL;
> -               }
> -       }
> -
> -       if (usb_ep_disable(ep))
> -               dev_err(uac2->card->dev,
> -                       "%s:%d Error!\n", __func__, __LINE__);
> -}
> -
>  static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>         struct usb_endpoint_descriptor *ep_desc,
>         unsigned int factor, bool is_playback)
> @@ -938,12 +477,11 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>  static int
>  afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
>  {
> -       struct audio_dev *agdev = func_to_agdev(fn);
> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
> +       struct f_uac2 *uac2 = func_to_uac2(fn);
> +       struct g_audio *agdev = func_to_g_audio(fn);
>         struct usb_composite_dev *cdev = cfg->cdev;
>         struct usb_gadget *gadget = cdev->gadget;
>         struct device *dev = &gadget->dev;
> -       struct uac2_rtd_params *prm;
>         struct f_uac2_opts *uac2_opts;
>         struct usb_string *us;
>         int ret;
> @@ -990,8 +528,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>                 return ret;
>         }
>         std_ac_if_desc.bInterfaceNumber = ret;
> -       agdev->ac_intf = ret;
> -       agdev->ac_alt = 0;
> +       uac2->ac_intf = ret;
> +       uac2->ac_alt = 0;
>
>         ret = usb_interface_id(cfg, fn);
>         if (ret < 0) {
> @@ -1000,8 +538,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>         }
>         std_as_out_if0_desc.bInterfaceNumber = ret;
>         std_as_out_if1_desc.bInterfaceNumber = ret;
> -       agdev->as_out_intf = ret;
> -       agdev->as_out_alt = 0;
> +       uac2->as_out_intf = ret;
> +       uac2->as_out_alt = 0;
>
>         ret = usb_interface_id(cfg, fn);
>         if (ret < 0) {
> @@ -1010,8 +548,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>         }
>         std_as_in_if0_desc.bInterfaceNumber = ret;
>         std_as_in_if1_desc.bInterfaceNumber = ret;
> -       agdev->as_in_intf = ret;
> -       agdev->as_in_alt = 0;
> +       uac2->as_in_intf = ret;
> +       uac2->as_in_alt = 0;
>
>         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
>         if (!agdev->out_ep) {
> @@ -1025,15 +563,17 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>                 return ret;
>         }
>
> -       uac2->p_prm.uac2 = uac2;
> -       uac2->c_prm.uac2 = uac2;
> -
>         /* Calculate wMaxPacketSize according to audio bandwidth */
>         set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
>         set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
>         set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
>         set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
>
> +       agdev->in_ep_maxpsize = max(fs_epin_desc.wMaxPacketSize,
> +                                       hs_epin_desc.wMaxPacketSize);
> +       agdev->out_ep_maxpsize = max(fs_epout_desc.wMaxPacketSize,
> +                                       hs_epout_desc.wMaxPacketSize);
> +
>         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
>         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
>
> @@ -1044,46 +584,18 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>
>         agdev->gadget = gadget;
>
> -       prm = &agdev->uac2.c_prm;
> -       prm->max_psize = hs_epout_desc.wMaxPacketSize;
> -       prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
> -                       GFP_KERNEL);
> -       if (!prm->ureq) {
> -               ret = -ENOMEM;
> -               goto err_free_descs;
> -       }
> -       prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
> -       if (!prm->rbuf) {
> -               prm->max_psize = 0;
> -               ret = -ENOMEM;
> -               goto err_free_descs;
> -       }
> -
> -       prm = &agdev->uac2.p_prm;
> -       prm->max_psize = hs_epin_desc.wMaxPacketSize;
> -       prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
> -                       GFP_KERNEL);
> -       if (!prm->ureq) {
> -               ret = -ENOMEM;
> -               goto err_free_descs;
> -       }
> -       prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
> -       if (!prm->rbuf) {
> -               prm->max_psize = 0;
> -               ret = -ENOMEM;
> -               goto err_no_memory;
> -       }
> -
> -       ret = snd_uac2_probe(agdev);
> +       agdev->params.p_chmask = uac2_opts->p_chmask;
> +       agdev->params.p_srate = uac2_opts->p_srate;
> +       agdev->params.p_ssize = uac2_opts->p_ssize;
> +       agdev->params.c_chmask = uac2_opts->c_chmask;
> +       agdev->params.c_srate = uac2_opts->c_srate;
> +       agdev->params.c_ssize = uac2_opts->c_ssize;
> +       agdev->params.req_number = uac2_opts->req_number;
> +       ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
>         if (ret)
> -               goto err_no_memory;
> +               goto err_free_descs;
>         return 0;
>
> -err_no_memory:
> -       kfree(agdev->uac2.p_prm.ureq);
> -       kfree(agdev->uac2.c_prm.ureq);
> -       kfree(agdev->uac2.p_prm.rbuf);
> -       kfree(agdev->uac2.c_prm.rbuf);
>  err_free_descs:
>         usb_free_all_descriptors(fn);
>         agdev->gadget = NULL;
> @@ -1094,15 +606,10 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>  afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
>  {
>         struct usb_composite_dev *cdev = fn->config->cdev;
> -       struct audio_dev *agdev = func_to_agdev(fn);
> -       struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>         struct usb_gadget *gadget = cdev->gadget;
>         struct device *dev = &gadget->dev;
> -       struct usb_request *req;
> -       struct usb_ep *ep;
> -       struct uac2_rtd_params *prm;
> -       int req_len, i;
> +       int ret = 0;
>
>         /* No i/f has more than 2 alt settings */
>         if (alt > 1) {
> @@ -1110,7 +617,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>                 return -EINVAL;
>         }
>
> -       if (intf == agdev->ac_intf) {
> +       if (intf == uac2->ac_intf) {
>                 /* Control I/f has only 1 AltSetting - 0 */
>                 if (alt) {
>                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
> @@ -1119,92 +626,40 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>                 return 0;
>         }
>
> -       if (intf == agdev->as_out_intf) {
> -               ep = agdev->out_ep;
> -               prm = &uac2->c_prm;
> -               config_ep_by_speed(gadget, fn, ep);
> -               agdev->as_out_alt = alt;
> -               req_len = prm->max_psize;
> -       } else if (intf == agdev->as_in_intf) {
> -               unsigned int factor, rate;
> -               struct usb_endpoint_descriptor *ep_desc;
> -
> -               ep = agdev->in_ep;
> -               prm = &uac2->p_prm;
> -               config_ep_by_speed(gadget, fn, ep);
> -               agdev->as_in_alt = alt;
> -
> -               /* pre-calculate the playback endpoint's interval */
> -               if (gadget->speed == USB_SPEED_FULL) {
> -                       ep_desc = &fs_epin_desc;
> -                       factor = 1000;
> -               } else {
> -                       ep_desc = &hs_epin_desc;
> -                       factor = 8000;
> -               }
> -
> -               /* pre-compute some values for iso_complete() */
> -               uac2->p_framesize = opts->p_ssize *
> -                                   num_channels(opts->p_chmask);
> -               rate = opts->p_srate * uac2->p_framesize;
> -               uac2->p_interval = factor / (1 << (ep_desc->bInterval - 1));
> -               uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
> -                                       prm->max_psize);
> +       if (intf == uac2->as_out_intf) {
> +               uac2->as_out_alt = alt;
>
> -               if (uac2->p_pktsize < prm->max_psize)
> -                       uac2->p_pktsize_residue = rate % uac2->p_interval;
> +               if (alt)
> +                       ret = u_audio_start_capture(&uac2->g_audio);
>                 else
> -                       uac2->p_pktsize_residue = 0;
> +                       u_audio_stop_capture(&uac2->g_audio);
> +       } else if (intf == uac2->as_in_intf) {
> +               uac2->as_in_alt = alt;
>
> -               req_len = uac2->p_pktsize;
> -               uac2->p_residue = 0;
> +               if (alt)
> +                       ret = u_audio_start_playback(&uac2->g_audio);
> +               else
> +                       u_audio_stop_playback(&uac2->g_audio);
>         } else {
>                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>                 return -EINVAL;
>         }
>
> -       if (alt == 0) {
> -               free_ep(prm, ep);
> -               return 0;
> -       }
> -
> -       prm->ep_enabled = true;
> -       usb_ep_enable(ep);
> -
> -       for (i = 0; i < opts->req_number; i++) {
> -               if (!prm->ureq[i].req) {
> -                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
> -                       if (req == NULL)
> -                               return -ENOMEM;
> -
> -                       prm->ureq[i].req = req;
> -                       prm->ureq[i].pp = prm;
> -
> -                       req->zero = 0;
> -                       req->context = &prm->ureq[i];
> -                       req->length = req_len;
> -                       req->complete = agdev_iso_complete;
> -                       req->buf = prm->rbuf + i * prm->max_psize;
> -               }
> -
> -               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
> -                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
> -       }
> -
> -       return 0;
> +       return ret;
>  }
>
>  static int
>  afunc_get_alt(struct usb_function *fn, unsigned intf)
>  {
> -       struct audio_dev *agdev = func_to_agdev(fn);
> -
> -       if (intf == agdev->ac_intf)
> -               return agdev->ac_alt;
> -       else if (intf == agdev->as_out_intf)
> -               return agdev->as_out_alt;
> -       else if (intf == agdev->as_in_intf)
> -               return agdev->as_in_alt;
> +       struct f_uac2 *uac2 = func_to_uac2(fn);
> +       struct g_audio *agdev = func_to_g_audio(fn);
> +
> +       if (intf == uac2->ac_intf)
> +               return uac2->ac_alt;
> +       else if (intf == uac2->as_out_intf)
> +               return uac2->as_out_alt;
> +       else if (intf == uac2->as_in_intf)
> +               return uac2->as_in_alt;
>         else
>                 dev_err(&agdev->gadget->dev,
>                         "%s:%d Invalid Interface %d!\n",
> @@ -1216,21 +671,19 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>  static void
>  afunc_disable(struct usb_function *fn)
>  {
> -       struct audio_dev *agdev = func_to_agdev(fn);
> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
> -
> -       free_ep(&uac2->p_prm, agdev->in_ep);
> -       agdev->as_in_alt = 0;
> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>
> -       free_ep(&uac2->c_prm, agdev->out_ep);
> -       agdev->as_out_alt = 0;
> +       uac2->as_in_alt = 0;
> +       uac2->as_out_alt = 0;
> +       u_audio_stop_capture(&uac2->g_audio);
> +       u_audio_stop_playback(&uac2->g_audio);
>  }
>
>  static int
>  in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>  {
>         struct usb_request *req = fn->config->cdev->req;
> -       struct audio_dev *agdev = func_to_agdev(fn);
> +       struct g_audio *agdev = func_to_g_audio(fn);
>         struct f_uac2_opts *opts;
>         u16 w_length = le16_to_cpu(cr->wLength);
>         u16 w_index = le16_to_cpu(cr->wIndex);
> @@ -1240,7 +693,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>         int value = -EOPNOTSUPP;
>         int p_srate, c_srate;
>
> -       opts = agdev_to_uac2_opts(agdev);
> +       opts = g_audio_to_uac2_opts(agdev);
>         p_srate = opts->p_srate;
>         c_srate = opts->c_srate;
>
> @@ -1271,7 +724,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>  in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>  {
>         struct usb_request *req = fn->config->cdev->req;
> -       struct audio_dev *agdev = func_to_agdev(fn);
> +       struct g_audio *agdev = func_to_g_audio(fn);
>         struct f_uac2_opts *opts;
>         u16 w_length = le16_to_cpu(cr->wLength);
>         u16 w_index = le16_to_cpu(cr->wIndex);
> @@ -1282,7 +735,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>         int value = -EOPNOTSUPP;
>         int p_srate, c_srate;
>
> -       opts = agdev_to_uac2_opts(agdev);
> +       opts = g_audio_to_uac2_opts(agdev);
>         p_srate = opts->p_srate;
>         c_srate = opts->c_srate;
>
> @@ -1336,11 +789,12 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>  static int
>  setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>  {
> -       struct audio_dev *agdev = func_to_agdev(fn);
> +       struct f_uac2 *uac2 = func_to_uac2(fn);
> +       struct g_audio *agdev = func_to_g_audio(fn);
>         u16 w_index = le16_to_cpu(cr->wIndex);
>         u8 intf = w_index & 0xff;
>
> -       if (intf != agdev->ac_intf) {
> +       if (intf != uac2->ac_intf) {
>                 dev_err(&agdev->gadget->dev,
>                         "%s:%d Error!\n", __func__, __LINE__);
>                 return -EOPNOTSUPP;
> @@ -1358,7 +812,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>  afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>  {
>         struct usb_composite_dev *cdev = fn->config->cdev;
> -       struct audio_dev *agdev = func_to_agdev(fn);
> +       struct g_audio *agdev = func_to_g_audio(fn);
>         struct usb_request *req = cdev->req;
>         u16 w_length = le16_to_cpu(cr->wLength);
>         int value = -EOPNOTSUPP;
> @@ -1504,10 +958,10 @@ static struct usb_function_instance *afunc_alloc_inst(void)
>
>  static void afunc_free(struct usb_function *f)
>  {
> -       struct audio_dev *agdev;
> +       struct g_audio *agdev;
>         struct f_uac2_opts *opts;
>
> -       agdev = func_to_agdev(f);
> +       agdev = func_to_g_audio(f);
>         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
>         kfree(agdev);
>         mutex_lock(&opts->lock);
> @@ -1517,17 +971,9 @@ static void afunc_free(struct usb_function *f)
>
>  static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
>  {
> -       struct audio_dev *agdev = func_to_agdev(f);
> -       struct uac2_rtd_params *prm;
> -
> -       snd_uac2_remove(agdev);
> -
> -       prm = &agdev->uac2.p_prm;
> -       kfree(prm->rbuf);
> +       struct g_audio *agdev = func_to_g_audio(f);
>
> -       prm = &agdev->uac2.c_prm;
> -       kfree(prm->rbuf);
> -       kfree(prm->ureq);
> +       g_audio_cleanup(agdev);
>         usb_free_all_descriptors(f);
>
>         agdev->gadget = NULL;
> @@ -1535,11 +981,11 @@ static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
>
>  static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
>  {
> -       struct audio_dev *agdev;
> +       struct f_uac2   *uac2;
>         struct f_uac2_opts *opts;
>
> -       agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
> -       if (agdev == NULL)
> +       uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
> +       if (uac2 == NULL)
>                 return ERR_PTR(-ENOMEM);
>
>         opts = container_of(fi, struct f_uac2_opts, func_inst);
> @@ -1547,19 +993,20 @@ static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
>         ++opts->refcnt;
>         mutex_unlock(&opts->lock);
>
> -       agdev->func.name = "uac2_func";
> -       agdev->func.bind = afunc_bind;
> -       agdev->func.unbind = afunc_unbind;
> -       agdev->func.set_alt = afunc_set_alt;
> -       agdev->func.get_alt = afunc_get_alt;
> -       agdev->func.disable = afunc_disable;
> -       agdev->func.setup = afunc_setup;
> -       agdev->func.free_func = afunc_free;
> +       uac2->g_audio.func.name = "uac2_func";
> +       uac2->g_audio.func.bind = afunc_bind;
> +       uac2->g_audio.func.unbind = afunc_unbind;
> +       uac2->g_audio.func.set_alt = afunc_set_alt;
> +       uac2->g_audio.func.get_alt = afunc_get_alt;
> +       uac2->g_audio.func.disable = afunc_disable;
> +       uac2->g_audio.func.setup = afunc_setup;
> +       uac2->g_audio.func.free_func = afunc_free;
>
> -       return &agdev->func;
> +       return &uac2->g_audio.func;
>  }
>
>  DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
>  MODULE_LICENSE("GPL");
>  MODULE_AUTHOR("Yadwinder Singh");
>  MODULE_AUTHOR("Jaswinder Singh");
> +MODULE_AUTHOR("Ruslan Bilovol");
>
drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------

Basically you move out ALSA sound card implementation and  %s/agdev/uac2/
I am not sure churn warrants a MODULE_AUTHOR. People have made far
more important contribution to the UAC2,


> diff --git a/drivers/usb/gadget/function/u_audio.c b/drivers/usb/gadget/function/u_audio.c
> new file mode 100644
> index 0000000..8ee65b8
> --- /dev/null
> +++ b/drivers/usb/gadget/function/u_audio.c
> @@ -0,0 +1,661 @@
> +/*
> + * u_audio.c -- interface to USB gadget "ALSA sound card" utilities
> + *
> + * Copyright (C) 2016
> + * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
> + *
> + * Based on f_uac2.c which is:
> + *    Copyright (C) 2011
> + *    Yadwinder Singh (yadi.brar01@gmail.com)
> + *    Jaswinder Singh (jaswinder.singh@linaro.org)
> + *
Again this is not "based on", rather where you paste the code you cut
from f_uac2.c
Of course you also pad it with minor changes to make it useful to your
uac1 code. I am not happy with losing copyright on the sound card
implementation for the UAC drivers.

> + * 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.
> + */
> +
> +#include <linux/module.h>
> +#include <sound/core.h>
> +#include <sound/pcm.h>
> +#include <sound/pcm_params.h>
> +
> +#include "u_audio.h"
> +
> +#define BUFF_SIZE_MAX  (PAGE_SIZE * 16)
> +#define PRD_SIZE_MAX   PAGE_SIZE
> +#define MIN_PERIODS    4
> +
> +struct uac_req {
> +       struct uac_rtd_params *pp; /* parent param */
> +       struct usb_request *req;
> +};
> +
> +/* Runtime data params for one stream */
> +struct uac_rtd_params {
> +       struct snd_uac_chip *uac; /* parent chip */
> +       bool ep_enabled; /* if the ep is enabled */
> +       /* Size of the ring buffer */
> +       size_t dma_bytes;
> +       unsigned char *dma_area;
> +
> +       struct snd_pcm_substream *ss;
> +
> +       /* Ring buffer */
> +       ssize_t hw_ptr;
> +
> +       void *rbuf;
> +
> +       size_t period_size;
> +
> +       unsigned max_psize;     /* MaxPacketSize of endpoint */
> +       struct uac_req *ureq;
> +
> +       spinlock_t lock;
> +};
> +
> +struct snd_uac_chip {
> +       struct g_audio *audio_dev;
> +
> +       struct uac_rtd_params p_prm;
> +       struct uac_rtd_params c_prm;
> +
> +       struct snd_card *card;
> +       struct snd_pcm *pcm;
> +
> +       /* timekeeping for the playback endpoint */
> +       unsigned int p_interval;
> +       unsigned int p_residue;
> +
> +       /* pre-calculated values for playback iso completion */
> +       unsigned int p_pktsize;
> +       unsigned int p_pktsize_residue;
> +       unsigned int p_framesize;
> +};
> +
> +static struct snd_pcm_hardware uac_pcm_hardware = {
> +       .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
> +                | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
> +                | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
> +       .rates = SNDRV_PCM_RATE_CONTINUOUS,
> +       .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
> +       .buffer_bytes_max = BUFF_SIZE_MAX,
> +       .period_bytes_max = PRD_SIZE_MAX,
> +       .periods_min = MIN_PERIODS,
> +};
> +
> +static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req)
> +{
> +       unsigned pending;
> +       unsigned long flags;
> +       unsigned int hw_ptr;
> +       bool update_alsa = false;
> +       int status = req->status;
> +       struct uac_req *ur = req->context;
> +       struct snd_pcm_substream *substream;
> +       struct uac_rtd_params *prm = ur->pp;
> +       struct snd_uac_chip *uac = prm->uac;
> +
> +       /* i/f shutting down */
> +       if (!prm->ep_enabled || req->status == -ESHUTDOWN)
> +               return;
> +
> +       /*
> +        * We can't really do much about bad xfers.
> +        * Afterall, the ISOCH xfers could fail legitimately.
> +        */
> +       if (status)
> +               pr_debug("%s: iso_complete status(%d) %d/%d\n",
> +                       __func__, status, req->actual, req->length);
> +
> +       substream = prm->ss;
> +
> +       /* Do nothing if ALSA isn't active */
> +       if (!substream)
> +               goto exit;
> +
> +       spin_lock_irqsave(&prm->lock, flags);
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> +               /*
> +                * For each IN packet, take the quotient of the current data
> +                * rate and the endpoint's interval as the base packet size.
> +                * If there is a residue from this division, add it to the
> +                * residue accumulator.
> +                */
> +               req->length = uac->p_pktsize;
> +               uac->p_residue += uac->p_pktsize_residue;
> +
> +               /*
> +                * Whenever there are more bytes in the accumulator than we
> +                * need to add one more sample frame, increase this packet's
> +                * size and decrease the accumulator.
> +                */
> +               if (uac->p_residue / uac->p_interval >= uac->p_framesize) {
> +                       req->length += uac->p_framesize;
> +                       uac->p_residue -= uac->p_framesize *
> +                                          uac->p_interval;
> +               }
> +
> +               req->actual = req->length;
> +       }
> +
> +       pending = prm->hw_ptr % prm->period_size;
> +       pending += req->actual;
> +       if (pending >= prm->period_size)
> +               update_alsa = true;
> +
> +       hw_ptr = prm->hw_ptr;
> +       prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
> +
> +       spin_unlock_irqrestore(&prm->lock, flags);
> +
> +       /* Pack USB load in ALSA ring buffer */
> +       pending = prm->dma_bytes - hw_ptr;
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> +               if (unlikely(pending < req->actual)) {
> +                       memcpy(req->buf, prm->dma_area + hw_ptr, pending);
> +                       memcpy(req->buf + pending, prm->dma_area,
> +                              req->actual - pending);
> +               } else {
> +                       memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
> +               }
> +       } else {
> +               if (unlikely(pending < req->actual)) {
> +                       memcpy(prm->dma_area + hw_ptr, req->buf, pending);
> +                       memcpy(prm->dma_area, req->buf + pending,
> +                              req->actual - pending);
> +               } else {
> +                       memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
> +               }
> +       }
> +
> +exit:
> +       if (usb_ep_queue(ep, req, GFP_ATOMIC))
> +               dev_err(uac->card->dev, "%d Error!\n", __LINE__);
> +
> +       if (update_alsa)
> +               snd_pcm_period_elapsed(substream);
> +}
> +
> +static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
> +{
> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
> +       struct uac_rtd_params *prm;
> +       struct g_audio *audio_dev;
> +       struct uac_params *params;
> +       unsigned long flags;
> +       int err = 0;
> +
> +       audio_dev = uac->audio_dev;
> +       params = &audio_dev->params;
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> +               prm = &uac->p_prm;
> +       else
> +               prm = &uac->c_prm;
> +
> +       spin_lock_irqsave(&prm->lock, flags);
> +
> +       /* Reset */
> +       prm->hw_ptr = 0;
> +
> +       switch (cmd) {
> +       case SNDRV_PCM_TRIGGER_START:
> +       case SNDRV_PCM_TRIGGER_RESUME:
> +               prm->ss = substream;
> +               break;
> +       case SNDRV_PCM_TRIGGER_STOP:
> +       case SNDRV_PCM_TRIGGER_SUSPEND:
> +               prm->ss = NULL;
> +               break;
> +       default:
> +               err = -EINVAL;
> +       }
> +
> +       spin_unlock_irqrestore(&prm->lock, flags);
> +
> +       /* Clear buffer after Play stops */
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
> +               memset(prm->rbuf, 0, prm->max_psize * params->req_number);
> +
> +       return err;
> +}
> +
> +static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream)
> +{
> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
> +       struct uac_rtd_params *prm;
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> +               prm = &uac->p_prm;
> +       else
> +               prm = &uac->c_prm;
> +
> +       return bytes_to_frames(substream->runtime, prm->hw_ptr);
> +}
> +
> +static int uac_pcm_hw_params(struct snd_pcm_substream *substream,
> +                              struct snd_pcm_hw_params *hw_params)
> +{
> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
> +       struct uac_rtd_params *prm;
> +       int err;
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> +               prm = &uac->p_prm;
> +       else
> +               prm = &uac->c_prm;
> +
> +       err = snd_pcm_lib_malloc_pages(substream,
> +                                       params_buffer_bytes(hw_params));
> +       if (err >= 0) {
> +               prm->dma_bytes = substream->runtime->dma_bytes;
> +               prm->dma_area = substream->runtime->dma_area;
> +               prm->period_size = params_period_bytes(hw_params);
> +       }
> +
> +       return err;
> +}
> +
> +static int uac_pcm_hw_free(struct snd_pcm_substream *substream)
> +{
> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
> +       struct uac_rtd_params *prm;
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
> +               prm = &uac->p_prm;
> +       else
> +               prm = &uac->c_prm;
> +
> +       prm->dma_area = NULL;
> +       prm->dma_bytes = 0;
> +       prm->period_size = 0;
> +
> +       return snd_pcm_lib_free_pages(substream);
> +}
> +
> +static int uac_pcm_open(struct snd_pcm_substream *substream)
> +{
> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
> +       struct snd_pcm_runtime *runtime = substream->runtime;
> +       struct g_audio *audio_dev;
> +       struct uac_params *params;
> +       int p_ssize, c_ssize;
> +       int p_srate, c_srate;
> +       int p_chmask, c_chmask;
> +
> +       audio_dev = uac->audio_dev;
> +       params = &audio_dev->params;
> +       p_ssize = params->p_ssize;
> +       c_ssize = params->c_ssize;
> +       p_srate = params->p_srate;
> +       c_srate = params->c_srate;
> +       p_chmask = params->p_chmask;
> +       c_chmask = params->c_chmask;
> +       uac->p_residue = 0;
> +
> +       runtime->hw = uac_pcm_hardware;
> +
> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> +               spin_lock_init(&uac->p_prm.lock);
> +               runtime->hw.rate_min = p_srate;
> +               switch (p_ssize) {
> +               case 3:
> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
> +                       break;
> +               case 4:
> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
> +                       break;
> +               default:
> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
> +                       break;
> +               }
> +               runtime->hw.channels_min = num_channels(p_chmask);
> +               runtime->hw.period_bytes_min = 2 * uac->p_prm.max_psize
> +                                               / runtime->hw.periods_min;
> +       } else {
> +               spin_lock_init(&uac->c_prm.lock);
> +               runtime->hw.rate_min = c_srate;
> +               switch (c_ssize) {
> +               case 3:
> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
> +                       break;
> +               case 4:
> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
> +                       break;
> +               default:
> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
> +                       break;
> +               }
> +               runtime->hw.channels_min = num_channels(c_chmask);
> +               runtime->hw.period_bytes_min = 2 * uac->c_prm.max_psize
> +                                               / runtime->hw.periods_min;
> +       }
> +
> +       runtime->hw.rate_max = runtime->hw.rate_min;
> +       runtime->hw.channels_max = runtime->hw.channels_min;
> +
> +       snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
> +
> +       return 0;
> +}
> +
> +/* ALSA cries without these function pointers */
> +static int uac_pcm_null(struct snd_pcm_substream *substream)
> +{
> +       return 0;
> +}
> +
> +static struct snd_pcm_ops uac_pcm_ops = {
> +       .open = uac_pcm_open,
> +       .close = uac_pcm_null,
> +       .ioctl = snd_pcm_lib_ioctl,
> +       .hw_params = uac_pcm_hw_params,
> +       .hw_free = uac_pcm_hw_free,
> +       .trigger = uac_pcm_trigger,
> +       .pointer = uac_pcm_pointer,
> +       .prepare = uac_pcm_null,
> +};
> +
> +static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep)
> +{
> +       struct snd_uac_chip *uac = prm->uac;
> +       struct g_audio *audio_dev;
> +       struct uac_params *params;
> +       int i;
> +
> +       if (!prm->ep_enabled)
> +               return;
> +
> +       prm->ep_enabled = false;
> +
> +       audio_dev = uac->audio_dev;
> +       params = &audio_dev->params;
> +
> +       for (i = 0; i < params->req_number; i++) {
> +               if (prm->ureq[i].req) {
> +                       usb_ep_dequeue(ep, prm->ureq[i].req);
> +                       usb_ep_free_request(ep, prm->ureq[i].req);
> +                       prm->ureq[i].req = NULL;
> +               }
> +       }
> +
> +       if (usb_ep_disable(ep))
> +               dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
> +}
> +
> +
> +int u_audio_start_capture(struct g_audio *audio_dev)
> +{
> +       struct snd_uac_chip *uac = audio_dev->uac;
> +       struct usb_gadget *gadget = audio_dev->gadget;
> +       struct device *dev = &gadget->dev;
> +       struct usb_request *req;
> +       struct usb_ep *ep;
> +       struct uac_rtd_params *prm;
> +       struct uac_params *params = &audio_dev->params;
> +       int req_len, i;
> +
> +       ep = audio_dev->out_ep;
> +       prm = &uac->c_prm;
> +       config_ep_by_speed(gadget, &audio_dev->func, ep);
> +       req_len = prm->max_psize;
> +
> +       prm->ep_enabled = true;
> +       usb_ep_enable(ep);
> +
> +       for (i = 0; i < params->req_number; i++) {
> +               if (!prm->ureq[i].req) {
> +                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
> +                       if (req == NULL)
> +                               return -ENOMEM;
> +
> +                       prm->ureq[i].req = req;
> +                       prm->ureq[i].pp = prm;
> +
> +                       req->zero = 0;
> +                       req->context = &prm->ureq[i];
> +                       req->length = req_len;
> +                       req->complete = u_audio_iso_complete;
> +                       req->buf = prm->rbuf + i * prm->max_psize;
> +               }
> +
> +               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
> +                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
> +       }
> +
> +       return 0;
> +}
> +EXPORT_SYMBOL_GPL(u_audio_start_capture);
> +
> +void u_audio_stop_capture(struct g_audio *audio_dev)
> +{
> +       struct snd_uac_chip *uac = audio_dev->uac;
> +
> +       free_ep(&uac->c_prm, audio_dev->out_ep);
> +}
> +EXPORT_SYMBOL_GPL(u_audio_stop_capture);
> +
> +int u_audio_start_playback(struct g_audio *audio_dev)
> +{
> +       struct snd_uac_chip *uac = audio_dev->uac;
> +       struct usb_gadget *gadget = audio_dev->gadget;
> +       struct device *dev = &gadget->dev;
> +       struct usb_request *req;
> +       struct usb_ep *ep;
> +       struct uac_rtd_params *prm;
> +       struct uac_params *params = &audio_dev->params;
> +       unsigned int factor, rate;
> +       const struct usb_endpoint_descriptor *ep_desc;
> +       int req_len, i;
> +
> +       ep = audio_dev->in_ep;
> +       prm = &uac->p_prm;
> +       config_ep_by_speed(gadget, &audio_dev->func, ep);
> +
> +       ep_desc = ep->desc;
> +
> +       /* pre-calculate the playback endpoint's interval */
> +       if (gadget->speed == USB_SPEED_FULL)
> +               factor = 1000;
> +       else
> +               factor = 8000;
> +
> +       /* pre-compute some values for iso_complete() */
> +       uac->p_framesize = params->p_ssize *
> +                           num_channels(params->p_chmask);
> +       rate = params->p_srate * uac->p_framesize;
> +       uac->p_interval = factor / (1 << (ep_desc->bInterval - 1));
> +       uac->p_pktsize = min_t(unsigned int, rate / uac->p_interval,
> +                               prm->max_psize);
> +
> +       if (uac->p_pktsize < prm->max_psize)
> +               uac->p_pktsize_residue = rate % uac->p_interval;
> +       else
> +               uac->p_pktsize_residue = 0;
> +
> +       req_len = uac->p_pktsize;
> +       uac->p_residue = 0;
> +
> +       prm->ep_enabled = true;
> +       usb_ep_enable(ep);
> +
> +       for (i = 0; i < params->req_number; i++) {
> +               if (!prm->ureq[i].req) {
> +                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
> +                       if (req == NULL)
> +                               return -ENOMEM;
> +
> +                       prm->ureq[i].req = req;
> +                       prm->ureq[i].pp = prm;
> +
> +                       req->zero = 0;
> +                       req->context = &prm->ureq[i];
> +                       req->length = req_len;
> +                       req->complete = u_audio_iso_complete;
> +                       req->buf = prm->rbuf + i * prm->max_psize;
> +               }
> +
> +               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
> +                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
> +       }
> +
> +       return 0;
> +}
> +EXPORT_SYMBOL_GPL(u_audio_start_playback);
> +
> +void u_audio_stop_playback(struct g_audio *audio_dev)
> +{
> +       struct snd_uac_chip *uac = audio_dev->uac;
> +
> +       free_ep(&uac->p_prm, audio_dev->in_ep);
> +}
> +EXPORT_SYMBOL_GPL(u_audio_stop_playback);
> +
> +int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
> +                                       const char *card_name)
> +{
> +       struct snd_uac_chip *uac;
> +       struct snd_card *card;
> +       struct snd_pcm *pcm;
> +       struct uac_params *params;
> +       int p_chmask, c_chmask;
> +       int err;
> +
> +       if (!g_audio)
> +               return -EINVAL;
> +
> +       uac = kzalloc(sizeof(*uac), GFP_KERNEL);
> +       if (!uac)
> +               return -ENOMEM;
> +       g_audio->uac = uac;
> +       uac->audio_dev = g_audio;
> +
> +       params = &g_audio->params;
> +       p_chmask = params->p_chmask;
> +       c_chmask = params->c_chmask;
> +
> +       if (c_chmask) {
> +               struct uac_rtd_params *prm = &uac->c_prm;
> +
> +               uac->c_prm.uac = uac;
> +               prm->max_psize = g_audio->out_ep_maxpsize;
> +
> +               prm->ureq = kcalloc(params->req_number, sizeof(struct uac_req),
> +                               GFP_KERNEL);
> +               if (!prm->ureq) {
> +                       err = -ENOMEM;
> +                       goto fail;
> +               }
> +
> +               prm->rbuf = kcalloc(params->req_number, prm->max_psize,
> +                               GFP_KERNEL);
> +               if (!prm->rbuf) {
> +                       prm->max_psize = 0;
> +                       err = -ENOMEM;
> +                       goto fail;
> +               }
> +       }
> +
> +       if (p_chmask) {
> +               struct uac_rtd_params *prm = &uac->p_prm;
> +
> +               uac->p_prm.uac = uac;
> +               prm->max_psize = g_audio->in_ep_maxpsize;
> +
> +               prm->ureq = kcalloc(params->req_number, sizeof(struct uac_req),
> +                               GFP_KERNEL);
> +               if (!prm->ureq) {
> +                       err = -ENOMEM;
> +                       goto fail;
> +               }
> +
> +               prm->rbuf = kcalloc(params->req_number, prm->max_psize,
> +                               GFP_KERNEL);
> +               if (!prm->rbuf) {
> +                       prm->max_psize = 0;
> +                       err = -ENOMEM;
> +                       goto fail;
> +               }
> +       }
> +
> +       /* Choose any slot, with no id */
> +       err = snd_card_new(&g_audio->gadget->dev,
> +                       -1, NULL, THIS_MODULE, 0, &card);
> +       if (err < 0)
> +               goto fail;
> +
> +       uac->card = card;
> +
> +       /*
> +        * Create first PCM device
> +        * Create a substream only for non-zero channel streams
> +        */
> +       err = snd_pcm_new(uac->card, pcm_name, 0,
> +                              p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
> +       if (err < 0)
> +               goto snd_fail;
> +
> +       strcpy(pcm->name, pcm_name);
> +       pcm->private_data = uac;
> +       uac->pcm = pcm;
> +
> +       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops);
> +       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops);
> +
> +       strcpy(card->driver, card_name);
> +       strcpy(card->shortname, card_name);
> +       sprintf(card->longname, "%s %i", card_name, card->dev->id);
> +
> +       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
> +               snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
> +
> +       err = snd_card_register(card);
> +
> +       if (!err)
> +               return 0;
> +
> +snd_fail:
> +       snd_card_free(card);
> +fail:
> +       kfree(uac->p_prm.ureq);
> +       kfree(uac->c_prm.ureq);
> +       kfree(uac->p_prm.rbuf);
> +       kfree(uac->c_prm.rbuf);
> +       kfree(uac);
> +
> +       return err;
> +}
> +EXPORT_SYMBOL_GPL(g_audio_setup);
> +
> +void g_audio_cleanup(struct g_audio *g_audio)
> +{
> +       struct snd_uac_chip *uac;
> +       struct snd_card *card;
> +
> +       if (!g_audio || !g_audio->uac)
> +               return;
> +
> +       uac = g_audio->uac;
> +       card = uac->card;
> +       if (card)
> +               snd_card_free(card);
> +
> +       kfree(uac->p_prm.ureq);
> +       kfree(uac->c_prm.ureq);
> +       kfree(uac->p_prm.rbuf);
> +       kfree(uac->c_prm.rbuf);
> +       kfree(uac);
> +}
> +EXPORT_SYMBOL_GPL(g_audio_cleanup);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities");
> +MODULE_AUTHOR("Ruslan Bilovol");
> diff --git a/drivers/usb/gadget/function/u_audio.h b/drivers/usb/gadget/function/u_audio.h
> new file mode 100644
> index 0000000..07e1378
> --- /dev/null
> +++ b/drivers/usb/gadget/function/u_audio.h
> @@ -0,0 +1,95 @@
> +/*
> + * u_audio.h -- interface to USB gadget "ALSA sound card" utilities
> + *
> + * Copyright (C) 2016
> + * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
> + *
> + * 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.
> + *
> + */
> +
> +#ifndef __U_AUDIO_H
> +#define __U_AUDIO_H
> +
> +#include <linux/usb/composite.h>
> +
> +struct uac_params {
> +       /* playback */
> +       int p_chmask;   /* channel mask */
> +       int p_srate;    /* rate in Hz */
> +       int p_ssize;    /* sample size */
> +
> +       /* capture */
> +       int c_chmask;   /* channel mask */
> +       int c_srate;    /* rate in Hz */
> +       int c_ssize;    /* sample size */
> +
> +       int req_number; /* number of preallocated requests */
> +};
> +
> +struct g_audio {
> +       struct usb_function func;
> +       struct usb_gadget *gadget;
> +
> +       struct usb_ep *in_ep;
> +       struct usb_ep *out_ep;
> +
> +       /* Max packet size for all in_ep possible speeds */
> +       unsigned int in_ep_maxpsize;
> +       /* Max packet size for all out_ep possible speeds */
> +       unsigned int out_ep_maxpsize;
> +
> +       /* The ALSA Sound Card it represents on the USB-Client side */
> +       struct snd_uac_chip *uac;
> +
> +       struct uac_params params;
> +};
> +
> +static inline struct g_audio *func_to_g_audio(struct usb_function *f)
> +{
> +       return container_of(f, struct g_audio, func);
> +}
> +
> +static inline uint num_channels(uint chanmask)
> +{
> +       uint num = 0;
> +
> +       while (chanmask) {
> +               num += (chanmask & 1);
> +               chanmask >>= 1;
> +       }
> +
> +       return num;
> +}
> +
> +/*
> + * g_audio_setup - initialize one virtual ALSA sound card
> + * @g_audio: struct with filled params, in_ep_maxpsize, out_ep_maxpsize
> + * @pcm_name: the id string for a PCM instance of this sound card
> + * @card_name: name of this soundcard
> + *
> + * This sets up the single virtual ALSA sound card that may be exported by a
> + * gadget driver using this framework.
> + *
> + * Context: may sleep
> + *
> + * Returns zero on success, or a negative error on failure.
> + */
> +int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
> +                                       const char *card_name);
> +void g_audio_cleanup(struct g_audio *g_audio);
> +
> +int u_audio_start_capture(struct g_audio *g_audio);
> +void u_audio_stop_capture(struct g_audio *g_audio);
> +int u_audio_start_playback(struct g_audio *g_audio);
> +void u_audio_stop_playback(struct g_audio *g_audio);
> +
> +#endif /* __U_AUDIO_H */
> diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
> index 0b36878..5344064 100644
> --- a/drivers/usb/gadget/legacy/Kconfig
> +++ b/drivers/usb/gadget/legacy/Kconfig
> @@ -56,6 +56,7 @@ config USB_AUDIO
>         select SND_PCM
>         select USB_F_UAC1 if GADGET_UAC1
>         select USB_F_UAC2 if !GADGET_UAC1
> +       select USB_U_AUDIO if USB_F_UAC2
>         help
>           This Gadget Audio driver is compatible with USB Audio Class
>           specification 2.0. It implements 1 AudioControl interface,
> --
> 1.9.1
>

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api
  2017-05-17 22:37 ` [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api Ruslan Bilovol
@ 2017-05-26 15:52   ` Julian Scheel
  2017-05-30  0:07     ` Ruslan Bilovol
  0 siblings, 1 reply; 17+ messages in thread
From: Julian Scheel @ 2017-05-26 15:52 UTC (permalink / raw)
  To: Ruslan Bilovol, Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, linux-usb, linux-doc,
	linux-kernel

On 18.05.2017 00:37, Ruslan Bilovol wrote:
> This patch adds a new function 'f_uac1_acard'
> (f_uac1 with virtual "ALSA card") that
> uses recently created u_audio API. Comparing
> to legacy f_uac1 function implementation it
> doesn't require any real Audio codec to be
> present on the device. In f_uac1_acard audio
> streams are simply sinked to and sourced
> from a virtual ALSA sound card created
> using u_audio API.
> 
> Legacy f_uac1 approach is to write audio
> samples directly to existing ALSA sound
> card
> 
> f_uac1_acard approach is more generic/flexible
> one - create an ALSA sound card that
> represents USB Audio function and allows to
> be used by userspace application that
> may choose to do whatever it wants with the
> data received from the USB Host and choose
> to provide whatever it wants as audio data
> to the USB Host.
> 
> f_uac1_acard also has capture support (gadget->host)
> thanks to easy implementation via u_audio.
> By default, capture interface has 48000kHz/2ch
> configuration, same as playback channel has.
> 
> f_uac1_acard descriptors naming convention
> uses f_uac2 driver naming convention that
> makes it more common and meaningful.
> 
> Comparing to f_uac1, the f_uac1_acard doesn't
> have volume/mute functionality. This is because
> the f_uac1 volume/mute feature unit was dummy
> implementation since that driver creation (2009)
> and never had any real volume control or mute
> functionality, so there is no any difference
> here.
> 
> Since f_uac1_acard functionality, exposed
> interface to userspace (virtual ALSA card),
> input parameters are so different comparing
> to legace f_uac1, that there is no any
> reason to keep them in the same file/module,
> and separate function was created.
> 
> g_audio can be built using one of existing
> UAC functions (f_uac1, f_uac1_acard or f_uac2)
> 
> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
> ---
>   .../ABI/testing/configfs-usb-gadget-uac1_acard     |  14 +
>   Documentation/usb/gadget-testing.txt               |  45 ++
>   drivers/usb/gadget/Kconfig                         |  21 +
>   drivers/usb/gadget/function/Makefile               |   2 +
>   drivers/usb/gadget/function/f_uac1_acard.c         | 803 +++++++++++++++++++++
>   drivers/usb/gadget/function/u_uac1_acard.h         |  41 ++
>   drivers/usb/gadget/legacy/Kconfig                  |  15 +-
>   drivers/usb/gadget/legacy/audio.c                  |  53 ++
>   8 files changed, 992 insertions(+), 2 deletions(-)
>   create mode 100644 Documentation/ABI/testing/configfs-usb-gadget-uac1_acard
>   create mode 100644 drivers/usb/gadget/function/f_uac1_acard.c
>   create mode 100644 drivers/usb/gadget/function/u_uac1_acard.h
> 

Tested on iMX7D using chipidea usb gadget controller. Tested Windows 10 
and Linux 4.11 as host. Both work fine.

Tested-by: Julian Scheel <julian@jusst.de>

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core
  2017-05-22 15:58   ` Jassi Brar
@ 2017-05-29 23:43     ` Ruslan Bilovol
  2017-06-02 11:47       ` Jassi Brar
  0 siblings, 1 reply; 17+ messages in thread
From: Ruslan Bilovol @ 2017-05-29 23:43 UTC (permalink / raw)
  To: Jassi Brar
  Cc: Felipe Balbi, Daniel Mack, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, Linux Kernel Mailing List

On Mon, May 22, 2017 at 6:58 PM, Jassi Brar <jassisinghbrar@gmail.com> wrote:
> On Thu, May 18, 2017 at 4:07 AM, Ruslan Bilovol
> <ruslan.bilovol@gmail.com> wrote:
>> Abstract the peripheral side ALSA sound card code from
>> the f_uac2 function into a component that can be called
>> by various functions, so the various flavors can be split
>> apart and selectively reused.
>>
>> Visible changes:
>>  - add uac_params structure to pass audio paramteres for
>>    g_audio_setup
>>  - make ALSA sound card's name configurable
>>  - add [in/out]_ep_maxpsize
>>  - allocate snd_uac_chip structure during g_audio_setup
>>  - add u_audio_[start/stop]_[capture/playback] functions
>>
>> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>> ---
>>  drivers/usb/gadget/Kconfig            |   4 +
>>  drivers/usb/gadget/function/Makefile  |   1 +
>>  drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------
>>  drivers/usb/gadget/function/u_audio.c | 661 +++++++++++++++++++++++++++++++
>>  drivers/usb/gadget/function/u_audio.h |  95 +++++
>>  drivers/usb/gadget/legacy/Kconfig     |   1 +
>>  6 files changed, 846 insertions(+), 637 deletions(-)
>>  create mode 100644 drivers/usb/gadget/function/u_audio.c
>>  create mode 100644 drivers/usb/gadget/function/u_audio.h
>>
>> diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
>> index c164d6b..2ba0ace 100644
>> --- a/drivers/usb/gadget/Kconfig
>> +++ b/drivers/usb/gadget/Kconfig
>> @@ -158,6 +158,9 @@ config USB_U_SERIAL
>>  config USB_U_ETHER
>>         tristate
>>
>> +config USB_U_AUDIO
>> +       tristate
>> +
>>  config USB_F_SERIAL
>>         tristate
>>
>> @@ -381,6 +384,7 @@ config USB_CONFIGFS_F_UAC2
>>         depends on SND
>>         select USB_LIBCOMPOSITE
>>         select SND_PCM
>> +       select USB_U_AUDIO
>>         select USB_F_UAC2
>>         help
>>           This Audio function is compatible with USB Audio Class
>> diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
>> index cb8c225..b29f2ae 100644
>> --- a/drivers/usb/gadget/function/Makefile
>> +++ b/drivers/usb/gadget/function/Makefile
>> @@ -32,6 +32,7 @@ usb_f_mass_storage-y          := f_mass_storage.o storage_common.o
>>  obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o
>>  usb_f_fs-y                     := f_fs.o
>>  obj-$(CONFIG_USB_F_FS)         += usb_f_fs.o
>> +obj-$(CONFIG_USB_U_AUDIO)      += u_audio.o
>>  usb_f_uac1-y                   := f_uac1.o u_uac1.o
>>  obj-$(CONFIG_USB_F_UAC1)       += usb_f_uac1.o
>>  usb_f_uac2-y                   := f_uac2.o
>> diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c
>> index d4565b5..059a14a 100644
>> --- a/drivers/usb/gadget/function/f_uac2.c
>> +++ b/drivers/usb/gadget/function/f_uac2.c
>> @@ -15,10 +15,7 @@
>>  #include <linux/usb/audio-v2.h>
>>  #include <linux/module.h>
>>
>> -#include <sound/core.h>
>> -#include <sound/pcm.h>
>> -#include <sound/pcm_params.h>
>> -
>> +#include "u_audio.h"
>>  #include "u_uac2.h"
>>
>>  /*
>> @@ -50,455 +47,23 @@
>>  #define UNFLW_CTRL     8
>>  #define OVFLW_CTRL     10
>>
>> -struct uac2_req {
>> -       struct uac2_rtd_params *pp; /* parent param */
>> -       struct usb_request *req;
>> -};
>> -
>> -struct uac2_rtd_params {
>> -       struct snd_uac2_chip *uac2; /* parent chip */
>> -       bool ep_enabled; /* if the ep is enabled */
>> -       /* Size of the ring buffer */
>> -       size_t dma_bytes;
>> -       unsigned char *dma_area;
>> -
>> -       struct snd_pcm_substream *ss;
>> -
>> -       /* Ring buffer */
>> -       ssize_t hw_ptr;
>> -
>> -       void *rbuf;
>> -
>> -       size_t period_size;
>> -
>> -       unsigned max_psize;
>> -       struct uac2_req *ureq;
>> -
>> -       spinlock_t lock;
>> -};
>> -
>> -struct snd_uac2_chip {
>> -       struct uac2_rtd_params p_prm;
>> -       struct uac2_rtd_params c_prm;
>> -
>> -       struct snd_card *card;
>> -       struct snd_pcm *pcm;
>> -
>> -       /* timekeeping for the playback endpoint */
>> -       unsigned int p_interval;
>> -       unsigned int p_residue;
>> -
>> -       /* pre-calculated values for playback iso completion */
>> -       unsigned int p_pktsize;
>> -       unsigned int p_pktsize_residue;
>> -       unsigned int p_framesize;
>> +struct f_uac2 {
>> +       struct g_audio g_audio;
>> +       u8 ac_intf, as_in_intf, as_out_intf;
>> +       u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
>>  };
>>
>> -#define BUFF_SIZE_MAX  (PAGE_SIZE * 16)
>> -#define PRD_SIZE_MAX   PAGE_SIZE
>> -#define MIN_PERIODS    4
>> -
>> -static struct snd_pcm_hardware uac2_pcm_hardware = {
>> -       .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
>> -                | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
>> -                | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
>> -       .rates = SNDRV_PCM_RATE_CONTINUOUS,
>> -       .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
>> -       .buffer_bytes_max = BUFF_SIZE_MAX,
>> -       .period_bytes_max = PRD_SIZE_MAX,
>> -       .periods_min = MIN_PERIODS,
>> -};
>> -
>> -struct audio_dev {
>> -       u8 ac_intf, ac_alt;
>> -       u8 as_out_intf, as_out_alt;
>> -       u8 as_in_intf, as_in_alt;
>> -
>> -       struct usb_ep *in_ep, *out_ep;
>> -       struct usb_function func;
>> -       struct usb_gadget *gadget;
>> -
>> -       /* The ALSA Sound Card it represents on the USB-Client side */
>> -       struct snd_uac2_chip uac2;
>> -};
>> -
>> -static inline
>> -struct audio_dev *func_to_agdev(struct usb_function *f)
>> +static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
>>  {
>> -       return container_of(f, struct audio_dev, func);
>> +       return container_of(f, struct f_uac2, g_audio.func);
>>  }
>>
>>  static inline
>> -struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
>> -{
>> -       return container_of(u, struct audio_dev, uac2);
>> -}
>> -
>> -static inline
>> -struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
>> +struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
>>  {
>>         return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
>>  }
>>
>> -static inline
>> -uint num_channels(uint chanmask)
>> -{
>> -       uint num = 0;
>> -
>> -       while (chanmask) {
>> -               num += (chanmask & 1);
>> -               chanmask >>= 1;
>> -       }
>> -
>> -       return num;
>> -}
>> -
>> -static void
>> -agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
>> -{
>> -       unsigned pending;
>> -       unsigned long flags;
>> -       unsigned int hw_ptr;
>> -       bool update_alsa = false;
>> -       int status = req->status;
>> -       struct uac2_req *ur = req->context;
>> -       struct snd_pcm_substream *substream;
>> -       struct uac2_rtd_params *prm = ur->pp;
>> -       struct snd_uac2_chip *uac2 = prm->uac2;
>> -
>> -       /* i/f shutting down */
>> -       if (!prm->ep_enabled || req->status == -ESHUTDOWN)
>> -               return;
>> -
>> -       /*
>> -        * We can't really do much about bad xfers.
>> -        * Afterall, the ISOCH xfers could fail legitimately.
>> -        */
>> -       if (status)
>> -               pr_debug("%s: iso_complete status(%d) %d/%d\n",
>> -                       __func__, status, req->actual, req->length);
>> -
>> -       substream = prm->ss;
>> -
>> -       /* Do nothing if ALSA isn't active */
>> -       if (!substream)
>> -               goto exit;
>> -
>> -       spin_lock_irqsave(&prm->lock, flags);
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>> -               /*
>> -                * For each IN packet, take the quotient of the current data
>> -                * rate and the endpoint's interval as the base packet size.
>> -                * If there is a residue from this division, add it to the
>> -                * residue accumulator.
>> -                */
>> -               req->length = uac2->p_pktsize;
>> -               uac2->p_residue += uac2->p_pktsize_residue;
>> -
>> -               /*
>> -                * Whenever there are more bytes in the accumulator than we
>> -                * need to add one more sample frame, increase this packet's
>> -                * size and decrease the accumulator.
>> -                */
>> -               if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
>> -                       req->length += uac2->p_framesize;
>> -                       uac2->p_residue -= uac2->p_framesize *
>> -                                          uac2->p_interval;
>> -               }
>> -
>> -               req->actual = req->length;
>> -       }
>> -
>> -       pending = prm->hw_ptr % prm->period_size;
>> -       pending += req->actual;
>> -       if (pending >= prm->period_size)
>> -               update_alsa = true;
>> -
>> -       hw_ptr = prm->hw_ptr;
>> -       prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
>> -
>> -       spin_unlock_irqrestore(&prm->lock, flags);
>> -
>> -       /* Pack USB load in ALSA ring buffer */
>> -       pending = prm->dma_bytes - hw_ptr;
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>> -               if (unlikely(pending < req->actual)) {
>> -                       memcpy(req->buf, prm->dma_area + hw_ptr, pending);
>> -                       memcpy(req->buf + pending, prm->dma_area,
>> -                              req->actual - pending);
>> -               } else {
>> -                       memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
>> -               }
>> -       } else {
>> -               if (unlikely(pending < req->actual)) {
>> -                       memcpy(prm->dma_area + hw_ptr, req->buf, pending);
>> -                       memcpy(prm->dma_area, req->buf + pending,
>> -                              req->actual - pending);
>> -               } else {
>> -                       memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
>> -               }
>> -       }
>> -
>> -exit:
>> -       if (usb_ep_queue(ep, req, GFP_ATOMIC))
>> -               dev_err(uac2->card->dev, "%d Error!\n", __LINE__);
>> -
>> -       if (update_alsa)
>> -               snd_pcm_period_elapsed(substream);
>> -
>> -       return;
>> -}
>> -
>> -static int
>> -uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
>> -{
>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>> -       struct audio_dev *agdev = uac2_to_agdev(uac2);
>> -       struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
>> -       struct uac2_rtd_params *prm;
>> -       unsigned long flags;
>> -       int err = 0;
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> -               prm = &uac2->p_prm;
>> -       else
>> -               prm = &uac2->c_prm;
>> -
>> -       spin_lock_irqsave(&prm->lock, flags);
>> -
>> -       /* Reset */
>> -       prm->hw_ptr = 0;
>> -
>> -       switch (cmd) {
>> -       case SNDRV_PCM_TRIGGER_START:
>> -       case SNDRV_PCM_TRIGGER_RESUME:
>> -               prm->ss = substream;
>> -               break;
>> -       case SNDRV_PCM_TRIGGER_STOP:
>> -       case SNDRV_PCM_TRIGGER_SUSPEND:
>> -               prm->ss = NULL;
>> -               break;
>> -       default:
>> -               err = -EINVAL;
>> -       }
>> -
>> -       spin_unlock_irqrestore(&prm->lock, flags);
>> -
>> -       /* Clear buffer after Play stops */
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
>> -               memset(prm->rbuf, 0, prm->max_psize * uac2_opts->req_number);
>> -
>> -       return err;
>> -}
>> -
>> -static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
>> -{
>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>> -       struct uac2_rtd_params *prm;
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> -               prm = &uac2->p_prm;
>> -       else
>> -               prm = &uac2->c_prm;
>> -
>> -       return bytes_to_frames(substream->runtime, prm->hw_ptr);
>> -}
>> -
>> -static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
>> -                              struct snd_pcm_hw_params *hw_params)
>> -{
>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>> -       struct uac2_rtd_params *prm;
>> -       int err;
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> -               prm = &uac2->p_prm;
>> -       else
>> -               prm = &uac2->c_prm;
>> -
>> -       err = snd_pcm_lib_malloc_pages(substream,
>> -                                       params_buffer_bytes(hw_params));
>> -       if (err >= 0) {
>> -               prm->dma_bytes = substream->runtime->dma_bytes;
>> -               prm->dma_area = substream->runtime->dma_area;
>> -               prm->period_size = params_period_bytes(hw_params);
>> -       }
>> -
>> -       return err;
>> -}
>> -
>> -static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
>> -{
>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>> -       struct uac2_rtd_params *prm;
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> -               prm = &uac2->p_prm;
>> -       else
>> -               prm = &uac2->c_prm;
>> -
>> -       prm->dma_area = NULL;
>> -       prm->dma_bytes = 0;
>> -       prm->period_size = 0;
>> -
>> -       return snd_pcm_lib_free_pages(substream);
>> -}
>> -
>> -static int uac2_pcm_open(struct snd_pcm_substream *substream)
>> -{
>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>> -       struct snd_pcm_runtime *runtime = substream->runtime;
>> -       struct audio_dev *audio_dev;
>> -       struct f_uac2_opts *opts;
>> -       int p_ssize, c_ssize;
>> -       int p_srate, c_srate;
>> -       int p_chmask, c_chmask;
>> -
>> -       audio_dev = uac2_to_agdev(uac2);
>> -       opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
>> -       p_ssize = opts->p_ssize;
>> -       c_ssize = opts->c_ssize;
>> -       p_srate = opts->p_srate;
>> -       c_srate = opts->c_srate;
>> -       p_chmask = opts->p_chmask;
>> -       c_chmask = opts->c_chmask;
>> -       uac2->p_residue = 0;
>> -
>> -       runtime->hw = uac2_pcm_hardware;
>> -
>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>> -               spin_lock_init(&uac2->p_prm.lock);
>> -               runtime->hw.rate_min = p_srate;
>> -               switch (p_ssize) {
>> -               case 3:
>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
>> -                       break;
>> -               case 4:
>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
>> -                       break;
>> -               default:
>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
>> -                       break;
>> -               }
>> -               runtime->hw.channels_min = num_channels(p_chmask);
>> -               runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
>> -                                               / runtime->hw.periods_min;
>> -       } else {
>> -               spin_lock_init(&uac2->c_prm.lock);
>> -               runtime->hw.rate_min = c_srate;
>> -               switch (c_ssize) {
>> -               case 3:
>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
>> -                       break;
>> -               case 4:
>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
>> -                       break;
>> -               default:
>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
>> -                       break;
>> -               }
>> -               runtime->hw.channels_min = num_channels(c_chmask);
>> -               runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
>> -                                               / runtime->hw.periods_min;
>> -       }
>> -
>> -       runtime->hw.rate_max = runtime->hw.rate_min;
>> -       runtime->hw.channels_max = runtime->hw.channels_min;
>> -
>> -       snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
>> -
>> -       return 0;
>> -}
>> -
>> -/* ALSA cries without these function pointers */
>> -static int uac2_pcm_null(struct snd_pcm_substream *substream)
>> -{
>> -       return 0;
>> -}
>> -
>> -static struct snd_pcm_ops uac2_pcm_ops = {
>> -       .open = uac2_pcm_open,
>> -       .close = uac2_pcm_null,
>> -       .ioctl = snd_pcm_lib_ioctl,
>> -       .hw_params = uac2_pcm_hw_params,
>> -       .hw_free = uac2_pcm_hw_free,
>> -       .trigger = uac2_pcm_trigger,
>> -       .pointer = uac2_pcm_pointer,
>> -       .prepare = uac2_pcm_null,
>> -};
>> -
>> -static int snd_uac2_probe(struct audio_dev *audio_dev)
>> -{
>> -       struct snd_uac2_chip *uac2 = &audio_dev->uac2;
>> -       struct snd_card *card;
>> -       struct snd_pcm *pcm;
>> -       struct f_uac2_opts *opts;
>> -       int err;
>> -       int p_chmask, c_chmask;
>> -
>> -       opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
>> -       p_chmask = opts->p_chmask;
>> -       c_chmask = opts->c_chmask;
>> -
>> -       /* Choose any slot, with no id */
>> -       err = snd_card_new(&audio_dev->gadget->dev,
>> -                       -1, NULL, THIS_MODULE, 0, &card);
>> -       if (err < 0)
>> -               return err;
>> -
>> -       uac2->card = card;
>> -
>> -       /*
>> -        * Create first PCM device
>> -        * Create a substream only for non-zero channel streams
>> -        */
>> -       err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
>> -                              p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
>> -       if (err < 0)
>> -               goto snd_fail;
>> -
>> -       strcpy(pcm->name, "UAC2 PCM");
>> -       pcm->private_data = uac2;
>> -
>> -       uac2->pcm = pcm;
>> -
>> -       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
>> -       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
>> -
>> -       strcpy(card->driver, "UAC2_Gadget");
>> -       strcpy(card->shortname, "UAC2_Gadget");
>> -       sprintf(card->longname, "UAC2_Gadget %i", card->dev->id);
>> -
>> -       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
>> -               snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
>> -
>> -       err = snd_card_register(card);
>> -
>> -       if (!err)
>> -               return 0;
>> -
>> -snd_fail:
>> -       snd_card_free(card);
>> -
>> -       uac2->pcm = NULL;
>> -       uac2->card = NULL;
>> -
>> -       return err;
>> -}
>> -
>> -static int snd_uac2_remove(struct audio_dev *audio_dev)
>> -{
>> -       struct snd_card *card = audio_dev->uac2.card;
>> -
>> -       if (card)
>> -               return snd_card_free(card);
>> -
>> -       return 0;
>> -}
>> -
>> -
>>  /* --------- USB Function Interface ------------- */
>>
>>  enum {
>> @@ -886,32 +451,6 @@ struct cntrl_range_lay3 {
>>         __u32   dRES;
>>  } __packed;
>>
>> -static inline void
>> -free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
>> -{
>> -       struct snd_uac2_chip *uac2 = prm->uac2;
>> -       struct audio_dev *agdev = uac2_to_agdev(uac2);
>> -       struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
>> -       int i;
>> -
>> -       if (!prm->ep_enabled)
>> -               return;
>> -
>> -       prm->ep_enabled = false;
>> -
>> -       for (i = 0; i < uac2_opts->req_number; i++) {
>> -               if (prm->ureq[i].req) {
>> -                       usb_ep_dequeue(ep, prm->ureq[i].req);
>> -                       usb_ep_free_request(ep, prm->ureq[i].req);
>> -                       prm->ureq[i].req = NULL;
>> -               }
>> -       }
>> -
>> -       if (usb_ep_disable(ep))
>> -               dev_err(uac2->card->dev,
>> -                       "%s:%d Error!\n", __func__, __LINE__);
>> -}
>> -
>>  static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>         struct usb_endpoint_descriptor *ep_desc,
>>         unsigned int factor, bool is_playback)
>> @@ -938,12 +477,11 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>  static int
>>  afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
>>  {
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>         struct usb_composite_dev *cdev = cfg->cdev;
>>         struct usb_gadget *gadget = cdev->gadget;
>>         struct device *dev = &gadget->dev;
>> -       struct uac2_rtd_params *prm;
>>         struct f_uac2_opts *uac2_opts;
>>         struct usb_string *us;
>>         int ret;
>> @@ -990,8 +528,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>                 return ret;
>>         }
>>         std_ac_if_desc.bInterfaceNumber = ret;
>> -       agdev->ac_intf = ret;
>> -       agdev->ac_alt = 0;
>> +       uac2->ac_intf = ret;
>> +       uac2->ac_alt = 0;
>>
>>         ret = usb_interface_id(cfg, fn);
>>         if (ret < 0) {
>> @@ -1000,8 +538,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>         }
>>         std_as_out_if0_desc.bInterfaceNumber = ret;
>>         std_as_out_if1_desc.bInterfaceNumber = ret;
>> -       agdev->as_out_intf = ret;
>> -       agdev->as_out_alt = 0;
>> +       uac2->as_out_intf = ret;
>> +       uac2->as_out_alt = 0;
>>
>>         ret = usb_interface_id(cfg, fn);
>>         if (ret < 0) {
>> @@ -1010,8 +548,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>         }
>>         std_as_in_if0_desc.bInterfaceNumber = ret;
>>         std_as_in_if1_desc.bInterfaceNumber = ret;
>> -       agdev->as_in_intf = ret;
>> -       agdev->as_in_alt = 0;
>> +       uac2->as_in_intf = ret;
>> +       uac2->as_in_alt = 0;
>>
>>         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
>>         if (!agdev->out_ep) {
>> @@ -1025,15 +563,17 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>                 return ret;
>>         }
>>
>> -       uac2->p_prm.uac2 = uac2;
>> -       uac2->c_prm.uac2 = uac2;
>> -
>>         /* Calculate wMaxPacketSize according to audio bandwidth */
>>         set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
>>         set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
>>         set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
>>         set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
>>
>> +       agdev->in_ep_maxpsize = max(fs_epin_desc.wMaxPacketSize,
>> +                                       hs_epin_desc.wMaxPacketSize);
>> +       agdev->out_ep_maxpsize = max(fs_epout_desc.wMaxPacketSize,
>> +                                       hs_epout_desc.wMaxPacketSize);
>> +
>>         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
>>         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
>>
>> @@ -1044,46 +584,18 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>
>>         agdev->gadget = gadget;
>>
>> -       prm = &agdev->uac2.c_prm;
>> -       prm->max_psize = hs_epout_desc.wMaxPacketSize;
>> -       prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
>> -                       GFP_KERNEL);
>> -       if (!prm->ureq) {
>> -               ret = -ENOMEM;
>> -               goto err_free_descs;
>> -       }
>> -       prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
>> -       if (!prm->rbuf) {
>> -               prm->max_psize = 0;
>> -               ret = -ENOMEM;
>> -               goto err_free_descs;
>> -       }
>> -
>> -       prm = &agdev->uac2.p_prm;
>> -       prm->max_psize = hs_epin_desc.wMaxPacketSize;
>> -       prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
>> -                       GFP_KERNEL);
>> -       if (!prm->ureq) {
>> -               ret = -ENOMEM;
>> -               goto err_free_descs;
>> -       }
>> -       prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
>> -       if (!prm->rbuf) {
>> -               prm->max_psize = 0;
>> -               ret = -ENOMEM;
>> -               goto err_no_memory;
>> -       }
>> -
>> -       ret = snd_uac2_probe(agdev);
>> +       agdev->params.p_chmask = uac2_opts->p_chmask;
>> +       agdev->params.p_srate = uac2_opts->p_srate;
>> +       agdev->params.p_ssize = uac2_opts->p_ssize;
>> +       agdev->params.c_chmask = uac2_opts->c_chmask;
>> +       agdev->params.c_srate = uac2_opts->c_srate;
>> +       agdev->params.c_ssize = uac2_opts->c_ssize;
>> +       agdev->params.req_number = uac2_opts->req_number;
>> +       ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
>>         if (ret)
>> -               goto err_no_memory;
>> +               goto err_free_descs;
>>         return 0;
>>
>> -err_no_memory:
>> -       kfree(agdev->uac2.p_prm.ureq);
>> -       kfree(agdev->uac2.c_prm.ureq);
>> -       kfree(agdev->uac2.p_prm.rbuf);
>> -       kfree(agdev->uac2.c_prm.rbuf);
>>  err_free_descs:
>>         usb_free_all_descriptors(fn);
>>         agdev->gadget = NULL;
>> @@ -1094,15 +606,10 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>  afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
>>  {
>>         struct usb_composite_dev *cdev = fn->config->cdev;
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> -       struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
>> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>         struct usb_gadget *gadget = cdev->gadget;
>>         struct device *dev = &gadget->dev;
>> -       struct usb_request *req;
>> -       struct usb_ep *ep;
>> -       struct uac2_rtd_params *prm;
>> -       int req_len, i;
>> +       int ret = 0;
>>
>>         /* No i/f has more than 2 alt settings */
>>         if (alt > 1) {
>> @@ -1110,7 +617,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>                 return -EINVAL;
>>         }
>>
>> -       if (intf == agdev->ac_intf) {
>> +       if (intf == uac2->ac_intf) {
>>                 /* Control I/f has only 1 AltSetting - 0 */
>>                 if (alt) {
>>                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>> @@ -1119,92 +626,40 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>                 return 0;
>>         }
>>
>> -       if (intf == agdev->as_out_intf) {
>> -               ep = agdev->out_ep;
>> -               prm = &uac2->c_prm;
>> -               config_ep_by_speed(gadget, fn, ep);
>> -               agdev->as_out_alt = alt;
>> -               req_len = prm->max_psize;
>> -       } else if (intf == agdev->as_in_intf) {
>> -               unsigned int factor, rate;
>> -               struct usb_endpoint_descriptor *ep_desc;
>> -
>> -               ep = agdev->in_ep;
>> -               prm = &uac2->p_prm;
>> -               config_ep_by_speed(gadget, fn, ep);
>> -               agdev->as_in_alt = alt;
>> -
>> -               /* pre-calculate the playback endpoint's interval */
>> -               if (gadget->speed == USB_SPEED_FULL) {
>> -                       ep_desc = &fs_epin_desc;
>> -                       factor = 1000;
>> -               } else {
>> -                       ep_desc = &hs_epin_desc;
>> -                       factor = 8000;
>> -               }
>> -
>> -               /* pre-compute some values for iso_complete() */
>> -               uac2->p_framesize = opts->p_ssize *
>> -                                   num_channels(opts->p_chmask);
>> -               rate = opts->p_srate * uac2->p_framesize;
>> -               uac2->p_interval = factor / (1 << (ep_desc->bInterval - 1));
>> -               uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
>> -                                       prm->max_psize);
>> +       if (intf == uac2->as_out_intf) {
>> +               uac2->as_out_alt = alt;
>>
>> -               if (uac2->p_pktsize < prm->max_psize)
>> -                       uac2->p_pktsize_residue = rate % uac2->p_interval;
>> +               if (alt)
>> +                       ret = u_audio_start_capture(&uac2->g_audio);
>>                 else
>> -                       uac2->p_pktsize_residue = 0;
>> +                       u_audio_stop_capture(&uac2->g_audio);
>> +       } else if (intf == uac2->as_in_intf) {
>> +               uac2->as_in_alt = alt;
>>
>> -               req_len = uac2->p_pktsize;
>> -               uac2->p_residue = 0;
>> +               if (alt)
>> +                       ret = u_audio_start_playback(&uac2->g_audio);
>> +               else
>> +                       u_audio_stop_playback(&uac2->g_audio);
>>         } else {
>>                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>>                 return -EINVAL;
>>         }
>>
>> -       if (alt == 0) {
>> -               free_ep(prm, ep);
>> -               return 0;
>> -       }
>> -
>> -       prm->ep_enabled = true;
>> -       usb_ep_enable(ep);
>> -
>> -       for (i = 0; i < opts->req_number; i++) {
>> -               if (!prm->ureq[i].req) {
>> -                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
>> -                       if (req == NULL)
>> -                               return -ENOMEM;
>> -
>> -                       prm->ureq[i].req = req;
>> -                       prm->ureq[i].pp = prm;
>> -
>> -                       req->zero = 0;
>> -                       req->context = &prm->ureq[i];
>> -                       req->length = req_len;
>> -                       req->complete = agdev_iso_complete;
>> -                       req->buf = prm->rbuf + i * prm->max_psize;
>> -               }
>> -
>> -               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
>> -                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>> -       }
>> -
>> -       return 0;
>> +       return ret;
>>  }
>>
>>  static int
>>  afunc_get_alt(struct usb_function *fn, unsigned intf)
>>  {
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> -
>> -       if (intf == agdev->ac_intf)
>> -               return agdev->ac_alt;
>> -       else if (intf == agdev->as_out_intf)
>> -               return agdev->as_out_alt;
>> -       else if (intf == agdev->as_in_intf)
>> -               return agdev->as_in_alt;
>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>> +       struct g_audio *agdev = func_to_g_audio(fn);
>> +
>> +       if (intf == uac2->ac_intf)
>> +               return uac2->ac_alt;
>> +       else if (intf == uac2->as_out_intf)
>> +               return uac2->as_out_alt;
>> +       else if (intf == uac2->as_in_intf)
>> +               return uac2->as_in_alt;
>>         else
>>                 dev_err(&agdev->gadget->dev,
>>                         "%s:%d Invalid Interface %d!\n",
>> @@ -1216,21 +671,19 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>  static void
>>  afunc_disable(struct usb_function *fn)
>>  {
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
>> -
>> -       free_ep(&uac2->p_prm, agdev->in_ep);
>> -       agdev->as_in_alt = 0;
>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>
>> -       free_ep(&uac2->c_prm, agdev->out_ep);
>> -       agdev->as_out_alt = 0;
>> +       uac2->as_in_alt = 0;
>> +       uac2->as_out_alt = 0;
>> +       u_audio_stop_capture(&uac2->g_audio);
>> +       u_audio_stop_playback(&uac2->g_audio);
>>  }
>>
>>  static int
>>  in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>  {
>>         struct usb_request *req = fn->config->cdev->req;
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>         struct f_uac2_opts *opts;
>>         u16 w_length = le16_to_cpu(cr->wLength);
>>         u16 w_index = le16_to_cpu(cr->wIndex);
>> @@ -1240,7 +693,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>         int value = -EOPNOTSUPP;
>>         int p_srate, c_srate;
>>
>> -       opts = agdev_to_uac2_opts(agdev);
>> +       opts = g_audio_to_uac2_opts(agdev);
>>         p_srate = opts->p_srate;
>>         c_srate = opts->c_srate;
>>
>> @@ -1271,7 +724,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>  in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>  {
>>         struct usb_request *req = fn->config->cdev->req;
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>         struct f_uac2_opts *opts;
>>         u16 w_length = le16_to_cpu(cr->wLength);
>>         u16 w_index = le16_to_cpu(cr->wIndex);
>> @@ -1282,7 +735,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>         int value = -EOPNOTSUPP;
>>         int p_srate, c_srate;
>>
>> -       opts = agdev_to_uac2_opts(agdev);
>> +       opts = g_audio_to_uac2_opts(agdev);
>>         p_srate = opts->p_srate;
>>         c_srate = opts->c_srate;
>>
>> @@ -1336,11 +789,12 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>  static int
>>  setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>  {
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>         u16 w_index = le16_to_cpu(cr->wIndex);
>>         u8 intf = w_index & 0xff;
>>
>> -       if (intf != agdev->ac_intf) {
>> +       if (intf != uac2->ac_intf) {
>>                 dev_err(&agdev->gadget->dev,
>>                         "%s:%d Error!\n", __func__, __LINE__);
>>                 return -EOPNOTSUPP;
>> @@ -1358,7 +812,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>  afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>  {
>>         struct usb_composite_dev *cdev = fn->config->cdev;
>> -       struct audio_dev *agdev = func_to_agdev(fn);
>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>         struct usb_request *req = cdev->req;
>>         u16 w_length = le16_to_cpu(cr->wLength);
>>         int value = -EOPNOTSUPP;
>> @@ -1504,10 +958,10 @@ static struct usb_function_instance *afunc_alloc_inst(void)
>>
>>  static void afunc_free(struct usb_function *f)
>>  {
>> -       struct audio_dev *agdev;
>> +       struct g_audio *agdev;
>>         struct f_uac2_opts *opts;
>>
>> -       agdev = func_to_agdev(f);
>> +       agdev = func_to_g_audio(f);
>>         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
>>         kfree(agdev);
>>         mutex_lock(&opts->lock);
>> @@ -1517,17 +971,9 @@ static void afunc_free(struct usb_function *f)
>>
>>  static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
>>  {
>> -       struct audio_dev *agdev = func_to_agdev(f);
>> -       struct uac2_rtd_params *prm;
>> -
>> -       snd_uac2_remove(agdev);
>> -
>> -       prm = &agdev->uac2.p_prm;
>> -       kfree(prm->rbuf);
>> +       struct g_audio *agdev = func_to_g_audio(f);
>>
>> -       prm = &agdev->uac2.c_prm;
>> -       kfree(prm->rbuf);
>> -       kfree(prm->ureq);
>> +       g_audio_cleanup(agdev);
>>         usb_free_all_descriptors(f);
>>
>>         agdev->gadget = NULL;
>> @@ -1535,11 +981,11 @@ static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
>>
>>  static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
>>  {
>> -       struct audio_dev *agdev;
>> +       struct f_uac2   *uac2;
>>         struct f_uac2_opts *opts;
>>
>> -       agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
>> -       if (agdev == NULL)
>> +       uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
>> +       if (uac2 == NULL)
>>                 return ERR_PTR(-ENOMEM);
>>
>>         opts = container_of(fi, struct f_uac2_opts, func_inst);
>> @@ -1547,19 +993,20 @@ static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
>>         ++opts->refcnt;
>>         mutex_unlock(&opts->lock);
>>
>> -       agdev->func.name = "uac2_func";
>> -       agdev->func.bind = afunc_bind;
>> -       agdev->func.unbind = afunc_unbind;
>> -       agdev->func.set_alt = afunc_set_alt;
>> -       agdev->func.get_alt = afunc_get_alt;
>> -       agdev->func.disable = afunc_disable;
>> -       agdev->func.setup = afunc_setup;
>> -       agdev->func.free_func = afunc_free;
>> +       uac2->g_audio.func.name = "uac2_func";
>> +       uac2->g_audio.func.bind = afunc_bind;
>> +       uac2->g_audio.func.unbind = afunc_unbind;
>> +       uac2->g_audio.func.set_alt = afunc_set_alt;
>> +       uac2->g_audio.func.get_alt = afunc_get_alt;
>> +       uac2->g_audio.func.disable = afunc_disable;
>> +       uac2->g_audio.func.setup = afunc_setup;
>> +       uac2->g_audio.func.free_func = afunc_free;
>>
>> -       return &agdev->func;
>> +       return &uac2->g_audio.func;
>>  }
>>
>>  DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
>>  MODULE_LICENSE("GPL");
>>  MODULE_AUTHOR("Yadwinder Singh");
>>  MODULE_AUTHOR("Jaswinder Singh");
>> +MODULE_AUTHOR("Ruslan Bilovol");
>>
> drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------
>
> Basically you move out ALSA sound card implementation and  %s/agdev/uac2/
> I am not sure churn warrants a MODULE_AUTHOR. People have made far
> more important contribution to the UAC2,

Yes, I added it after cumulative effect of this patch and patch 1/3
where I removed  platform driver/device creation from f_uac2.
I haven't find any rules on this and just counted changed lines,
however in this particular case it's better to use something
like MODULE_CLEANER(). Just joking :)

I'll remove this line then.

>
>
>> diff --git a/drivers/usb/gadget/function/u_audio.c b/drivers/usb/gadget/function/u_audio.c
>> new file mode 100644
>> index 0000000..8ee65b8
>> --- /dev/null
>> +++ b/drivers/usb/gadget/function/u_audio.c
>> @@ -0,0 +1,661 @@
>> +/*
>> + * u_audio.c -- interface to USB gadget "ALSA sound card" utilities
>> + *
>> + * Copyright (C) 2016
>> + * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>> + *
>> + * Based on f_uac2.c which is:
>> + *    Copyright (C) 2011
>> + *    Yadwinder Singh (yadi.brar01@gmail.com)
>> + *    Jaswinder Singh (jaswinder.singh@linaro.org)
>> + *
> Again this is not "based on", rather where you paste the code you cut
> from f_uac2.c
> Of course you also pad it with minor changes to make it useful to your
> uac1 code. I am not happy with losing copyright on the sound card
> implementation for the UAC drivers.

I don't remember why I wrote it as "based on" back in 2016,
probably looking into another patches as example. As per my
understanding, "based on" + your name in Copyright means
that you still continue to hold copyright on the sound card
implementation (otherwise why mention it?).
However I'm not a lawyer so can't say for sure.
Will change this description in next patchset to make it clear,
so you won't loose your copyright.

Best regards
Ruslan

>
>> + * 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.
>> + */
>> +
>> +#include <linux/module.h>
>> +#include <sound/core.h>
>> +#include <sound/pcm.h>
>> +#include <sound/pcm_params.h>
>> +
>> +#include "u_audio.h"
>> +
>> +#define BUFF_SIZE_MAX  (PAGE_SIZE * 16)
>> +#define PRD_SIZE_MAX   PAGE_SIZE
>> +#define MIN_PERIODS    4
>> +
>> +struct uac_req {
>> +       struct uac_rtd_params *pp; /* parent param */
>> +       struct usb_request *req;
>> +};
>> +
>> +/* Runtime data params for one stream */
>> +struct uac_rtd_params {
>> +       struct snd_uac_chip *uac; /* parent chip */
>> +       bool ep_enabled; /* if the ep is enabled */
>> +       /* Size of the ring buffer */
>> +       size_t dma_bytes;
>> +       unsigned char *dma_area;
>> +
>> +       struct snd_pcm_substream *ss;
>> +
>> +       /* Ring buffer */
>> +       ssize_t hw_ptr;
>> +
>> +       void *rbuf;
>> +
>> +       size_t period_size;
>> +
>> +       unsigned max_psize;     /* MaxPacketSize of endpoint */
>> +       struct uac_req *ureq;
>> +
>> +       spinlock_t lock;
>> +};
>> +
>> +struct snd_uac_chip {
>> +       struct g_audio *audio_dev;
>> +
>> +       struct uac_rtd_params p_prm;
>> +       struct uac_rtd_params c_prm;
>> +
>> +       struct snd_card *card;
>> +       struct snd_pcm *pcm;
>> +
>> +       /* timekeeping for the playback endpoint */
>> +       unsigned int p_interval;
>> +       unsigned int p_residue;
>> +
>> +       /* pre-calculated values for playback iso completion */
>> +       unsigned int p_pktsize;
>> +       unsigned int p_pktsize_residue;
>> +       unsigned int p_framesize;
>> +};
>> +
>> +static struct snd_pcm_hardware uac_pcm_hardware = {
>> +       .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
>> +                | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
>> +                | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
>> +       .rates = SNDRV_PCM_RATE_CONTINUOUS,
>> +       .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
>> +       .buffer_bytes_max = BUFF_SIZE_MAX,
>> +       .period_bytes_max = PRD_SIZE_MAX,
>> +       .periods_min = MIN_PERIODS,
>> +};
>> +
>> +static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req)
>> +{
>> +       unsigned pending;
>> +       unsigned long flags;
>> +       unsigned int hw_ptr;
>> +       bool update_alsa = false;
>> +       int status = req->status;
>> +       struct uac_req *ur = req->context;
>> +       struct snd_pcm_substream *substream;
>> +       struct uac_rtd_params *prm = ur->pp;
>> +       struct snd_uac_chip *uac = prm->uac;
>> +
>> +       /* i/f shutting down */
>> +       if (!prm->ep_enabled || req->status == -ESHUTDOWN)
>> +               return;
>> +
>> +       /*
>> +        * We can't really do much about bad xfers.
>> +        * Afterall, the ISOCH xfers could fail legitimately.
>> +        */
>> +       if (status)
>> +               pr_debug("%s: iso_complete status(%d) %d/%d\n",
>> +                       __func__, status, req->actual, req->length);
>> +
>> +       substream = prm->ss;
>> +
>> +       /* Do nothing if ALSA isn't active */
>> +       if (!substream)
>> +               goto exit;
>> +
>> +       spin_lock_irqsave(&prm->lock, flags);
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>> +               /*
>> +                * For each IN packet, take the quotient of the current data
>> +                * rate and the endpoint's interval as the base packet size.
>> +                * If there is a residue from this division, add it to the
>> +                * residue accumulator.
>> +                */
>> +               req->length = uac->p_pktsize;
>> +               uac->p_residue += uac->p_pktsize_residue;
>> +
>> +               /*
>> +                * Whenever there are more bytes in the accumulator than we
>> +                * need to add one more sample frame, increase this packet's
>> +                * size and decrease the accumulator.
>> +                */
>> +               if (uac->p_residue / uac->p_interval >= uac->p_framesize) {
>> +                       req->length += uac->p_framesize;
>> +                       uac->p_residue -= uac->p_framesize *
>> +                                          uac->p_interval;
>> +               }
>> +
>> +               req->actual = req->length;
>> +       }
>> +
>> +       pending = prm->hw_ptr % prm->period_size;
>> +       pending += req->actual;
>> +       if (pending >= prm->period_size)
>> +               update_alsa = true;
>> +
>> +       hw_ptr = prm->hw_ptr;
>> +       prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
>> +
>> +       spin_unlock_irqrestore(&prm->lock, flags);
>> +
>> +       /* Pack USB load in ALSA ring buffer */
>> +       pending = prm->dma_bytes - hw_ptr;
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>> +               if (unlikely(pending < req->actual)) {
>> +                       memcpy(req->buf, prm->dma_area + hw_ptr, pending);
>> +                       memcpy(req->buf + pending, prm->dma_area,
>> +                              req->actual - pending);
>> +               } else {
>> +                       memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
>> +               }
>> +       } else {
>> +               if (unlikely(pending < req->actual)) {
>> +                       memcpy(prm->dma_area + hw_ptr, req->buf, pending);
>> +                       memcpy(prm->dma_area, req->buf + pending,
>> +                              req->actual - pending);
>> +               } else {
>> +                       memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
>> +               }
>> +       }
>> +
>> +exit:
>> +       if (usb_ep_queue(ep, req, GFP_ATOMIC))
>> +               dev_err(uac->card->dev, "%d Error!\n", __LINE__);
>> +
>> +       if (update_alsa)
>> +               snd_pcm_period_elapsed(substream);
>> +}
>> +
>> +static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
>> +{
>> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
>> +       struct uac_rtd_params *prm;
>> +       struct g_audio *audio_dev;
>> +       struct uac_params *params;
>> +       unsigned long flags;
>> +       int err = 0;
>> +
>> +       audio_dev = uac->audio_dev;
>> +       params = &audio_dev->params;
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> +               prm = &uac->p_prm;
>> +       else
>> +               prm = &uac->c_prm;
>> +
>> +       spin_lock_irqsave(&prm->lock, flags);
>> +
>> +       /* Reset */
>> +       prm->hw_ptr = 0;
>> +
>> +       switch (cmd) {
>> +       case SNDRV_PCM_TRIGGER_START:
>> +       case SNDRV_PCM_TRIGGER_RESUME:
>> +               prm->ss = substream;
>> +               break;
>> +       case SNDRV_PCM_TRIGGER_STOP:
>> +       case SNDRV_PCM_TRIGGER_SUSPEND:
>> +               prm->ss = NULL;
>> +               break;
>> +       default:
>> +               err = -EINVAL;
>> +       }
>> +
>> +       spin_unlock_irqrestore(&prm->lock, flags);
>> +
>> +       /* Clear buffer after Play stops */
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
>> +               memset(prm->rbuf, 0, prm->max_psize * params->req_number);
>> +
>> +       return err;
>> +}
>> +
>> +static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream)
>> +{
>> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
>> +       struct uac_rtd_params *prm;
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> +               prm = &uac->p_prm;
>> +       else
>> +               prm = &uac->c_prm;
>> +
>> +       return bytes_to_frames(substream->runtime, prm->hw_ptr);
>> +}
>> +
>> +static int uac_pcm_hw_params(struct snd_pcm_substream *substream,
>> +                              struct snd_pcm_hw_params *hw_params)
>> +{
>> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
>> +       struct uac_rtd_params *prm;
>> +       int err;
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> +               prm = &uac->p_prm;
>> +       else
>> +               prm = &uac->c_prm;
>> +
>> +       err = snd_pcm_lib_malloc_pages(substream,
>> +                                       params_buffer_bytes(hw_params));
>> +       if (err >= 0) {
>> +               prm->dma_bytes = substream->runtime->dma_bytes;
>> +               prm->dma_area = substream->runtime->dma_area;
>> +               prm->period_size = params_period_bytes(hw_params);
>> +       }
>> +
>> +       return err;
>> +}
>> +
>> +static int uac_pcm_hw_free(struct snd_pcm_substream *substream)
>> +{
>> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
>> +       struct uac_rtd_params *prm;
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>> +               prm = &uac->p_prm;
>> +       else
>> +               prm = &uac->c_prm;
>> +
>> +       prm->dma_area = NULL;
>> +       prm->dma_bytes = 0;
>> +       prm->period_size = 0;
>> +
>> +       return snd_pcm_lib_free_pages(substream);
>> +}
>> +
>> +static int uac_pcm_open(struct snd_pcm_substream *substream)
>> +{
>> +       struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
>> +       struct snd_pcm_runtime *runtime = substream->runtime;
>> +       struct g_audio *audio_dev;
>> +       struct uac_params *params;
>> +       int p_ssize, c_ssize;
>> +       int p_srate, c_srate;
>> +       int p_chmask, c_chmask;
>> +
>> +       audio_dev = uac->audio_dev;
>> +       params = &audio_dev->params;
>> +       p_ssize = params->p_ssize;
>> +       c_ssize = params->c_ssize;
>> +       p_srate = params->p_srate;
>> +       c_srate = params->c_srate;
>> +       p_chmask = params->p_chmask;
>> +       c_chmask = params->c_chmask;
>> +       uac->p_residue = 0;
>> +
>> +       runtime->hw = uac_pcm_hardware;
>> +
>> +       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>> +               spin_lock_init(&uac->p_prm.lock);
>> +               runtime->hw.rate_min = p_srate;
>> +               switch (p_ssize) {
>> +               case 3:
>> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
>> +                       break;
>> +               case 4:
>> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
>> +                       break;
>> +               default:
>> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
>> +                       break;
>> +               }
>> +               runtime->hw.channels_min = num_channels(p_chmask);
>> +               runtime->hw.period_bytes_min = 2 * uac->p_prm.max_psize
>> +                                               / runtime->hw.periods_min;
>> +       } else {
>> +               spin_lock_init(&uac->c_prm.lock);
>> +               runtime->hw.rate_min = c_srate;
>> +               switch (c_ssize) {
>> +               case 3:
>> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
>> +                       break;
>> +               case 4:
>> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
>> +                       break;
>> +               default:
>> +                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
>> +                       break;
>> +               }
>> +               runtime->hw.channels_min = num_channels(c_chmask);
>> +               runtime->hw.period_bytes_min = 2 * uac->c_prm.max_psize
>> +                                               / runtime->hw.periods_min;
>> +       }
>> +
>> +       runtime->hw.rate_max = runtime->hw.rate_min;
>> +       runtime->hw.channels_max = runtime->hw.channels_min;
>> +
>> +       snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
>> +
>> +       return 0;
>> +}
>> +
>> +/* ALSA cries without these function pointers */
>> +static int uac_pcm_null(struct snd_pcm_substream *substream)
>> +{
>> +       return 0;
>> +}
>> +
>> +static struct snd_pcm_ops uac_pcm_ops = {
>> +       .open = uac_pcm_open,
>> +       .close = uac_pcm_null,
>> +       .ioctl = snd_pcm_lib_ioctl,
>> +       .hw_params = uac_pcm_hw_params,
>> +       .hw_free = uac_pcm_hw_free,
>> +       .trigger = uac_pcm_trigger,
>> +       .pointer = uac_pcm_pointer,
>> +       .prepare = uac_pcm_null,
>> +};
>> +
>> +static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep)
>> +{
>> +       struct snd_uac_chip *uac = prm->uac;
>> +       struct g_audio *audio_dev;
>> +       struct uac_params *params;
>> +       int i;
>> +
>> +       if (!prm->ep_enabled)
>> +               return;
>> +
>> +       prm->ep_enabled = false;
>> +
>> +       audio_dev = uac->audio_dev;
>> +       params = &audio_dev->params;
>> +
>> +       for (i = 0; i < params->req_number; i++) {
>> +               if (prm->ureq[i].req) {
>> +                       usb_ep_dequeue(ep, prm->ureq[i].req);
>> +                       usb_ep_free_request(ep, prm->ureq[i].req);
>> +                       prm->ureq[i].req = NULL;
>> +               }
>> +       }
>> +
>> +       if (usb_ep_disable(ep))
>> +               dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
>> +}
>> +
>> +
>> +int u_audio_start_capture(struct g_audio *audio_dev)
>> +{
>> +       struct snd_uac_chip *uac = audio_dev->uac;
>> +       struct usb_gadget *gadget = audio_dev->gadget;
>> +       struct device *dev = &gadget->dev;
>> +       struct usb_request *req;
>> +       struct usb_ep *ep;
>> +       struct uac_rtd_params *prm;
>> +       struct uac_params *params = &audio_dev->params;
>> +       int req_len, i;
>> +
>> +       ep = audio_dev->out_ep;
>> +       prm = &uac->c_prm;
>> +       config_ep_by_speed(gadget, &audio_dev->func, ep);
>> +       req_len = prm->max_psize;
>> +
>> +       prm->ep_enabled = true;
>> +       usb_ep_enable(ep);
>> +
>> +       for (i = 0; i < params->req_number; i++) {
>> +               if (!prm->ureq[i].req) {
>> +                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
>> +                       if (req == NULL)
>> +                               return -ENOMEM;
>> +
>> +                       prm->ureq[i].req = req;
>> +                       prm->ureq[i].pp = prm;
>> +
>> +                       req->zero = 0;
>> +                       req->context = &prm->ureq[i];
>> +                       req->length = req_len;
>> +                       req->complete = u_audio_iso_complete;
>> +                       req->buf = prm->rbuf + i * prm->max_psize;
>> +               }
>> +
>> +               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
>> +                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>> +       }
>> +
>> +       return 0;
>> +}
>> +EXPORT_SYMBOL_GPL(u_audio_start_capture);
>> +
>> +void u_audio_stop_capture(struct g_audio *audio_dev)
>> +{
>> +       struct snd_uac_chip *uac = audio_dev->uac;
>> +
>> +       free_ep(&uac->c_prm, audio_dev->out_ep);
>> +}
>> +EXPORT_SYMBOL_GPL(u_audio_stop_capture);
>> +
>> +int u_audio_start_playback(struct g_audio *audio_dev)
>> +{
>> +       struct snd_uac_chip *uac = audio_dev->uac;
>> +       struct usb_gadget *gadget = audio_dev->gadget;
>> +       struct device *dev = &gadget->dev;
>> +       struct usb_request *req;
>> +       struct usb_ep *ep;
>> +       struct uac_rtd_params *prm;
>> +       struct uac_params *params = &audio_dev->params;
>> +       unsigned int factor, rate;
>> +       const struct usb_endpoint_descriptor *ep_desc;
>> +       int req_len, i;
>> +
>> +       ep = audio_dev->in_ep;
>> +       prm = &uac->p_prm;
>> +       config_ep_by_speed(gadget, &audio_dev->func, ep);
>> +
>> +       ep_desc = ep->desc;
>> +
>> +       /* pre-calculate the playback endpoint's interval */
>> +       if (gadget->speed == USB_SPEED_FULL)
>> +               factor = 1000;
>> +       else
>> +               factor = 8000;
>> +
>> +       /* pre-compute some values for iso_complete() */
>> +       uac->p_framesize = params->p_ssize *
>> +                           num_channels(params->p_chmask);
>> +       rate = params->p_srate * uac->p_framesize;
>> +       uac->p_interval = factor / (1 << (ep_desc->bInterval - 1));
>> +       uac->p_pktsize = min_t(unsigned int, rate / uac->p_interval,
>> +                               prm->max_psize);
>> +
>> +       if (uac->p_pktsize < prm->max_psize)
>> +               uac->p_pktsize_residue = rate % uac->p_interval;
>> +       else
>> +               uac->p_pktsize_residue = 0;
>> +
>> +       req_len = uac->p_pktsize;
>> +       uac->p_residue = 0;
>> +
>> +       prm->ep_enabled = true;
>> +       usb_ep_enable(ep);
>> +
>> +       for (i = 0; i < params->req_number; i++) {
>> +               if (!prm->ureq[i].req) {
>> +                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
>> +                       if (req == NULL)
>> +                               return -ENOMEM;
>> +
>> +                       prm->ureq[i].req = req;
>> +                       prm->ureq[i].pp = prm;
>> +
>> +                       req->zero = 0;
>> +                       req->context = &prm->ureq[i];
>> +                       req->length = req_len;
>> +                       req->complete = u_audio_iso_complete;
>> +                       req->buf = prm->rbuf + i * prm->max_psize;
>> +               }
>> +
>> +               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
>> +                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>> +       }
>> +
>> +       return 0;
>> +}
>> +EXPORT_SYMBOL_GPL(u_audio_start_playback);
>> +
>> +void u_audio_stop_playback(struct g_audio *audio_dev)
>> +{
>> +       struct snd_uac_chip *uac = audio_dev->uac;
>> +
>> +       free_ep(&uac->p_prm, audio_dev->in_ep);
>> +}
>> +EXPORT_SYMBOL_GPL(u_audio_stop_playback);
>> +
>> +int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
>> +                                       const char *card_name)
>> +{
>> +       struct snd_uac_chip *uac;
>> +       struct snd_card *card;
>> +       struct snd_pcm *pcm;
>> +       struct uac_params *params;
>> +       int p_chmask, c_chmask;
>> +       int err;
>> +
>> +       if (!g_audio)
>> +               return -EINVAL;
>> +
>> +       uac = kzalloc(sizeof(*uac), GFP_KERNEL);
>> +       if (!uac)
>> +               return -ENOMEM;
>> +       g_audio->uac = uac;
>> +       uac->audio_dev = g_audio;
>> +
>> +       params = &g_audio->params;
>> +       p_chmask = params->p_chmask;
>> +       c_chmask = params->c_chmask;
>> +
>> +       if (c_chmask) {
>> +               struct uac_rtd_params *prm = &uac->c_prm;
>> +
>> +               uac->c_prm.uac = uac;
>> +               prm->max_psize = g_audio->out_ep_maxpsize;
>> +
>> +               prm->ureq = kcalloc(params->req_number, sizeof(struct uac_req),
>> +                               GFP_KERNEL);
>> +               if (!prm->ureq) {
>> +                       err = -ENOMEM;
>> +                       goto fail;
>> +               }
>> +
>> +               prm->rbuf = kcalloc(params->req_number, prm->max_psize,
>> +                               GFP_KERNEL);
>> +               if (!prm->rbuf) {
>> +                       prm->max_psize = 0;
>> +                       err = -ENOMEM;
>> +                       goto fail;
>> +               }
>> +       }
>> +
>> +       if (p_chmask) {
>> +               struct uac_rtd_params *prm = &uac->p_prm;
>> +
>> +               uac->p_prm.uac = uac;
>> +               prm->max_psize = g_audio->in_ep_maxpsize;
>> +
>> +               prm->ureq = kcalloc(params->req_number, sizeof(struct uac_req),
>> +                               GFP_KERNEL);
>> +               if (!prm->ureq) {
>> +                       err = -ENOMEM;
>> +                       goto fail;
>> +               }
>> +
>> +               prm->rbuf = kcalloc(params->req_number, prm->max_psize,
>> +                               GFP_KERNEL);
>> +               if (!prm->rbuf) {
>> +                       prm->max_psize = 0;
>> +                       err = -ENOMEM;
>> +                       goto fail;
>> +               }
>> +       }
>> +
>> +       /* Choose any slot, with no id */
>> +       err = snd_card_new(&g_audio->gadget->dev,
>> +                       -1, NULL, THIS_MODULE, 0, &card);
>> +       if (err < 0)
>> +               goto fail;
>> +
>> +       uac->card = card;
>> +
>> +       /*
>> +        * Create first PCM device
>> +        * Create a substream only for non-zero channel streams
>> +        */
>> +       err = snd_pcm_new(uac->card, pcm_name, 0,
>> +                              p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
>> +       if (err < 0)
>> +               goto snd_fail;
>> +
>> +       strcpy(pcm->name, pcm_name);
>> +       pcm->private_data = uac;
>> +       uac->pcm = pcm;
>> +
>> +       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops);
>> +       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops);
>> +
>> +       strcpy(card->driver, card_name);
>> +       strcpy(card->shortname, card_name);
>> +       sprintf(card->longname, "%s %i", card_name, card->dev->id);
>> +
>> +       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
>> +               snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
>> +
>> +       err = snd_card_register(card);
>> +
>> +       if (!err)
>> +               return 0;
>> +
>> +snd_fail:
>> +       snd_card_free(card);
>> +fail:
>> +       kfree(uac->p_prm.ureq);
>> +       kfree(uac->c_prm.ureq);
>> +       kfree(uac->p_prm.rbuf);
>> +       kfree(uac->c_prm.rbuf);
>> +       kfree(uac);
>> +
>> +       return err;
>> +}
>> +EXPORT_SYMBOL_GPL(g_audio_setup);
>> +
>> +void g_audio_cleanup(struct g_audio *g_audio)
>> +{
>> +       struct snd_uac_chip *uac;
>> +       struct snd_card *card;
>> +
>> +       if (!g_audio || !g_audio->uac)
>> +               return;
>> +
>> +       uac = g_audio->uac;
>> +       card = uac->card;
>> +       if (card)
>> +               snd_card_free(card);
>> +
>> +       kfree(uac->p_prm.ureq);
>> +       kfree(uac->c_prm.ureq);
>> +       kfree(uac->p_prm.rbuf);
>> +       kfree(uac->c_prm.rbuf);
>> +       kfree(uac);
>> +}
>> +EXPORT_SYMBOL_GPL(g_audio_cleanup);
>> +
>> +MODULE_LICENSE("GPL");
>> +MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities");
>> +MODULE_AUTHOR("Ruslan Bilovol");
>> diff --git a/drivers/usb/gadget/function/u_audio.h b/drivers/usb/gadget/function/u_audio.h
>> new file mode 100644
>> index 0000000..07e1378
>> --- /dev/null
>> +++ b/drivers/usb/gadget/function/u_audio.h
>> @@ -0,0 +1,95 @@
>> +/*
>> + * u_audio.h -- interface to USB gadget "ALSA sound card" utilities
>> + *
>> + * Copyright (C) 2016
>> + * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>> + *
>> + * 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.
>> + *
>> + */
>> +
>> +#ifndef __U_AUDIO_H
>> +#define __U_AUDIO_H
>> +
>> +#include <linux/usb/composite.h>
>> +
>> +struct uac_params {
>> +       /* playback */
>> +       int p_chmask;   /* channel mask */
>> +       int p_srate;    /* rate in Hz */
>> +       int p_ssize;    /* sample size */
>> +
>> +       /* capture */
>> +       int c_chmask;   /* channel mask */
>> +       int c_srate;    /* rate in Hz */
>> +       int c_ssize;    /* sample size */
>> +
>> +       int req_number; /* number of preallocated requests */
>> +};
>> +
>> +struct g_audio {
>> +       struct usb_function func;
>> +       struct usb_gadget *gadget;
>> +
>> +       struct usb_ep *in_ep;
>> +       struct usb_ep *out_ep;
>> +
>> +       /* Max packet size for all in_ep possible speeds */
>> +       unsigned int in_ep_maxpsize;
>> +       /* Max packet size for all out_ep possible speeds */
>> +       unsigned int out_ep_maxpsize;
>> +
>> +       /* The ALSA Sound Card it represents on the USB-Client side */
>> +       struct snd_uac_chip *uac;
>> +
>> +       struct uac_params params;
>> +};
>> +
>> +static inline struct g_audio *func_to_g_audio(struct usb_function *f)
>> +{
>> +       return container_of(f, struct g_audio, func);
>> +}
>> +
>> +static inline uint num_channels(uint chanmask)
>> +{
>> +       uint num = 0;
>> +
>> +       while (chanmask) {
>> +               num += (chanmask & 1);
>> +               chanmask >>= 1;
>> +       }
>> +
>> +       return num;
>> +}
>> +
>> +/*
>> + * g_audio_setup - initialize one virtual ALSA sound card
>> + * @g_audio: struct with filled params, in_ep_maxpsize, out_ep_maxpsize
>> + * @pcm_name: the id string for a PCM instance of this sound card
>> + * @card_name: name of this soundcard
>> + *
>> + * This sets up the single virtual ALSA sound card that may be exported by a
>> + * gadget driver using this framework.
>> + *
>> + * Context: may sleep
>> + *
>> + * Returns zero on success, or a negative error on failure.
>> + */
>> +int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
>> +                                       const char *card_name);
>> +void g_audio_cleanup(struct g_audio *g_audio);
>> +
>> +int u_audio_start_capture(struct g_audio *g_audio);
>> +void u_audio_stop_capture(struct g_audio *g_audio);
>> +int u_audio_start_playback(struct g_audio *g_audio);
>> +void u_audio_stop_playback(struct g_audio *g_audio);
>> +
>> +#endif /* __U_AUDIO_H */
>> diff --git a/drivers/usb/gadget/legacy/Kconfig b/drivers/usb/gadget/legacy/Kconfig
>> index 0b36878..5344064 100644
>> --- a/drivers/usb/gadget/legacy/Kconfig
>> +++ b/drivers/usb/gadget/legacy/Kconfig
>> @@ -56,6 +56,7 @@ config USB_AUDIO
>>         select SND_PCM
>>         select USB_F_UAC1 if GADGET_UAC1
>>         select USB_F_UAC2 if !GADGET_UAC1
>> +       select USB_U_AUDIO if USB_F_UAC2
>>         help
>>           This Gadget Audio driver is compatible with USB Audio Class
>>           specification 2.0. It implements 1 AudioControl interface,
>> --
>> 1.9.1
>>

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api
  2017-05-26 15:52   ` Julian Scheel
@ 2017-05-30  0:07     ` Ruslan Bilovol
  0 siblings, 0 replies; 17+ messages in thread
From: Ruslan Bilovol @ 2017-05-30  0:07 UTC (permalink / raw)
  To: Julian Scheel
  Cc: Felipe Balbi, Daniel Mack, Jassi Brar, Clemens Ladisch,
	Jonathan Corbet, Greg Kroah-Hartman, Peter Chen, linux-usb,
	linux-doc, linux-kernel

On Fri, May 26, 2017 at 6:52 PM, Julian Scheel <julian@jusst.de> wrote:
> On 18.05.2017 00:37, Ruslan Bilovol wrote:
>>
>> This patch adds a new function 'f_uac1_acard'
>> (f_uac1 with virtual "ALSA card") that
>> uses recently created u_audio API. Comparing
>> to legacy f_uac1 function implementation it
>> doesn't require any real Audio codec to be
>> present on the device. In f_uac1_acard audio
>> streams are simply sinked to and sourced
>> from a virtual ALSA sound card created
>> using u_audio API.
>>
>> Legacy f_uac1 approach is to write audio
>> samples directly to existing ALSA sound
>> card
>>
>> f_uac1_acard approach is more generic/flexible
>> one - create an ALSA sound card that
>> represents USB Audio function and allows to
>> be used by userspace application that
>> may choose to do whatever it wants with the
>> data received from the USB Host and choose
>> to provide whatever it wants as audio data
>> to the USB Host.
>>
>> f_uac1_acard also has capture support (gadget->host)
>> thanks to easy implementation via u_audio.
>> By default, capture interface has 48000kHz/2ch
>> configuration, same as playback channel has.
>>
>> f_uac1_acard descriptors naming convention
>> uses f_uac2 driver naming convention that
>> makes it more common and meaningful.
>>
>> Comparing to f_uac1, the f_uac1_acard doesn't
>> have volume/mute functionality. This is because
>> the f_uac1 volume/mute feature unit was dummy
>> implementation since that driver creation (2009)
>> and never had any real volume control or mute
>> functionality, so there is no any difference
>> here.
>>
>> Since f_uac1_acard functionality, exposed
>> interface to userspace (virtual ALSA card),
>> input parameters are so different comparing
>> to legace f_uac1, that there is no any
>> reason to keep them in the same file/module,
>> and separate function was created.
>>
>> g_audio can be built using one of existing
>> UAC functions (f_uac1, f_uac1_acard or f_uac2)
>>
>> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>> ---
>>   .../ABI/testing/configfs-usb-gadget-uac1_acard     |  14 +
>>   Documentation/usb/gadget-testing.txt               |  45 ++
>>   drivers/usb/gadget/Kconfig                         |  21 +
>>   drivers/usb/gadget/function/Makefile               |   2 +
>>   drivers/usb/gadget/function/f_uac1_acard.c         | 803
>> +++++++++++++++++++++
>>   drivers/usb/gadget/function/u_uac1_acard.h         |  41 ++
>>   drivers/usb/gadget/legacy/Kconfig                  |  15 +-
>>   drivers/usb/gadget/legacy/audio.c                  |  53 ++
>>   8 files changed, 992 insertions(+), 2 deletions(-)
>>   create mode 100644
>> Documentation/ABI/testing/configfs-usb-gadget-uac1_acard
>>   create mode 100644 drivers/usb/gadget/function/f_uac1_acard.c
>>   create mode 100644 drivers/usb/gadget/function/u_uac1_acard.h
>>
>
> Tested on iMX7D using chipidea usb gadget controller. Tested Windows 10 and
> Linux 4.11 as host. Both work fine.
>
> Tested-by: Julian Scheel <julian@jusst.de>

Thanks for testing it.

I'll wait for additional reviews/comments next few days and than will
send new patchset with addressed comments.

Also current patchset have minor conflict when applied on top of
Felipe's testing/next branch which is moved to 4.12-rc1. I've
resolved conflict but did only build test so far.
Anyway I uploaded rebased patches to github [1] if anybody
wants to try them.

[1] https://github.com/rbilovol/kernel/commits/usbaudio-v4.12-balbi-testing-next

Best regards,
Ruslan

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core
  2017-05-17 22:37 ` [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core Ruslan Bilovol
  2017-05-22 15:58   ` Jassi Brar
@ 2017-06-02  9:34   ` Felipe Balbi
  2017-06-02 21:11     ` Ruslan Bilovol
  1 sibling, 1 reply; 17+ messages in thread
From: Felipe Balbi @ 2017-06-02  9:34 UTC (permalink / raw)
  To: Ruslan Bilovol
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

[-- Attachment #1: Type: text/plain, Size: 703 bytes --]


Hi,

Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
> Abstract the peripheral side ALSA sound card code from
> the f_uac2 function into a component that can be called
> by various functions, so the various flavors can be split
> apart and selectively reused.
>
> Visible changes:
>  - add uac_params structure to pass audio paramteres for
>    g_audio_setup
>  - make ALSA sound card's name configurable
>  - add [in/out]_ep_maxpsize
>  - allocate snd_uac_chip structure during g_audio_setup
>  - add u_audio_[start/stop]_[capture/playback] functions
>
> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>

this doesn't apply on testing/next, care to rebase?

-- 
balbi

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 0/3] USB Audio Gadget refactoring
  2017-05-17 22:37 [PATCH v4 0/3] USB Audio Gadget refactoring Ruslan Bilovol
                   ` (2 preceding siblings ...)
  2017-05-17 22:37 ` [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api Ruslan Bilovol
@ 2017-06-02  9:42 ` Felipe Balbi
  2017-06-02 21:36   ` Ruslan Bilovol
  3 siblings, 1 reply; 17+ messages in thread
From: Felipe Balbi @ 2017-06-02  9:42 UTC (permalink / raw)
  To: Ruslan Bilovol
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

[-- Attachment #1: Type: text/plain, Size: 2822 bytes --]


Hi,

Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
> I came to this patch series when wanted to do two things:
>  - use UAC1 as virtual ALSA sound card on gadget side,
>    just like UAC2 is used so it's possible to do rate
>    resampling
>  - have both playback/capture support in UAC1
>
> Since I wanted to have same behavior for both UAC1/UAC2,
> obviously I've got an utility part (u_audio.c) for
> virtual ALSA sound card handling like we have
> for ethernet(u_ether) or serial(u_serial) functions.
> Function-specific parts (f_uac1/f_uac2) became almost 
> as storage for class-specific USB descriptors, some
> boilerplate for configfs, binding and few USB
> config request handling.
>
> Originally in RFC [1] I've posted before, there was
> major change to f_uac1 after that it couldn't do
> direct play to existing ALSA sound card anymore,
> representing audio on gadget side as virtual
> ALSA sound card where audio streams are simply
> sinked to and sourced from it, so it may break
> current usecase for some people (and that's why
> it was RFC).
>
> During RFC discussion, it was agreed to not touch
> existing f_uac1 implementation and create new one
> instead. This patchset (v4) introduced new function
> named f_uac1_acard and doesn't touch current f_uac1
> implementation, so people still can use old behavior

Do you have a pointer to the original RFC discussion where this was
discussed? If we really *must* keep the old implementation, I would
rather rename that to f_uac1_legacy. Still, I find it unlikely that
anybody will care about the old implementation.

> Now, it's possible to use existing user-space
> applications for audio routing between Audio Gadget
> and real sound card. I personally use alsaloop tool
> from alsautils and have ability to create PCM
> loopback between two different ALSA cards using
> rate resampling, which was not possible with previous
> "direct play to ALSA card" approach in f_uac1. 

this is really good result and will actually make it a lot easier for
testing things out.

> While here, also dropped redundant platform
> driver/device creation in f_uac2 driver (as well as
> didn't add "never implemented" volume/mute functionality
> in f_uac1 to f_uac1_acard) that made this work even
> easier to do.
>
> This series is tested with both legacy g_audio.ko and
> modern configfs approaches under Ubuntu 14.04 (UAC1 and
> UAC2) and under Windows7 x64 (UAC1 only) having
> perfect results in all cases.
>
> Comments, testing are welcome.
>
> v4 changes:
>  - renamed f_uac1_newapi to f_uac1_acard that is
>    more meaningful

I really don't get why you wanna keep both f_uac1 and f_uac1_acard. Why
do we need to maintain the old uac1 implementation? Why two separate
files?

-- 
balbi

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core
  2017-05-29 23:43     ` Ruslan Bilovol
@ 2017-06-02 11:47       ` Jassi Brar
  0 siblings, 0 replies; 17+ messages in thread
From: Jassi Brar @ 2017-06-02 11:47 UTC (permalink / raw)
  To: Ruslan Bilovol
  Cc: Felipe Balbi, Daniel Mack, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, Linux Kernel Mailing List

On Tue, May 30, 2017 at 5:13 AM, Ruslan Bilovol
<ruslan.bilovol@gmail.com> wrote:
> On Mon, May 22, 2017 at 6:58 PM, Jassi Brar <jassisinghbrar@gmail.com> wrote:
>> On Thu, May 18, 2017 at 4:07 AM, Ruslan Bilovol
>> <ruslan.bilovol@gmail.com> wrote:
>>> Abstract the peripheral side ALSA sound card code from
>>> the f_uac2 function into a component that can be called
>>> by various functions, so the various flavors can be split
>>> apart and selectively reused.
>>>
>>> Visible changes:
>>>  - add uac_params structure to pass audio paramteres for
>>>    g_audio_setup
>>>  - make ALSA sound card's name configurable
>>>  - add [in/out]_ep_maxpsize
>>>  - allocate snd_uac_chip structure during g_audio_setup
>>>  - add u_audio_[start/stop]_[capture/playback] functions
>>>
>>> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>>> ---
>>>  drivers/usb/gadget/Kconfig            |   4 +
>>>  drivers/usb/gadget/function/Makefile  |   1 +
>>>  drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------
>>>  drivers/usb/gadget/function/u_audio.c | 661 +++++++++++++++++++++++++++++++
>>>  drivers/usb/gadget/function/u_audio.h |  95 +++++
>>>  drivers/usb/gadget/legacy/Kconfig     |   1 +
>>>  6 files changed, 846 insertions(+), 637 deletions(-)
>>>  create mode 100644 drivers/usb/gadget/function/u_audio.c
>>>  create mode 100644 drivers/usb/gadget/function/u_audio.h
>>>
>>> diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
>>> index c164d6b..2ba0ace 100644
>>> --- a/drivers/usb/gadget/Kconfig
>>> +++ b/drivers/usb/gadget/Kconfig
>>> @@ -158,6 +158,9 @@ config USB_U_SERIAL
>>>  config USB_U_ETHER
>>>         tristate
>>>
>>> +config USB_U_AUDIO
>>> +       tristate
>>> +
>>>  config USB_F_SERIAL
>>>         tristate
>>>
>>> @@ -381,6 +384,7 @@ config USB_CONFIGFS_F_UAC2
>>>         depends on SND
>>>         select USB_LIBCOMPOSITE
>>>         select SND_PCM
>>> +       select USB_U_AUDIO
>>>         select USB_F_UAC2
>>>         help
>>>           This Audio function is compatible with USB Audio Class
>>> diff --git a/drivers/usb/gadget/function/Makefile b/drivers/usb/gadget/function/Makefile
>>> index cb8c225..b29f2ae 100644
>>> --- a/drivers/usb/gadget/function/Makefile
>>> +++ b/drivers/usb/gadget/function/Makefile
>>> @@ -32,6 +32,7 @@ usb_f_mass_storage-y          := f_mass_storage.o storage_common.o
>>>  obj-$(CONFIG_USB_F_MASS_STORAGE)+= usb_f_mass_storage.o
>>>  usb_f_fs-y                     := f_fs.o
>>>  obj-$(CONFIG_USB_F_FS)         += usb_f_fs.o
>>> +obj-$(CONFIG_USB_U_AUDIO)      += u_audio.o
>>>  usb_f_uac1-y                   := f_uac1.o u_uac1.o
>>>  obj-$(CONFIG_USB_F_UAC1)       += usb_f_uac1.o
>>>  usb_f_uac2-y                   := f_uac2.o
>>> diff --git a/drivers/usb/gadget/function/f_uac2.c b/drivers/usb/gadget/function/f_uac2.c
>>> index d4565b5..059a14a 100644
>>> --- a/drivers/usb/gadget/function/f_uac2.c
>>> +++ b/drivers/usb/gadget/function/f_uac2.c
>>> @@ -15,10 +15,7 @@
>>>  #include <linux/usb/audio-v2.h>
>>>  #include <linux/module.h>
>>>
>>> -#include <sound/core.h>
>>> -#include <sound/pcm.h>
>>> -#include <sound/pcm_params.h>
>>> -
>>> +#include "u_audio.h"
>>>  #include "u_uac2.h"
>>>
>>>  /*
>>> @@ -50,455 +47,23 @@
>>>  #define UNFLW_CTRL     8
>>>  #define OVFLW_CTRL     10
>>>
>>> -struct uac2_req {
>>> -       struct uac2_rtd_params *pp; /* parent param */
>>> -       struct usb_request *req;
>>> -};
>>> -
>>> -struct uac2_rtd_params {
>>> -       struct snd_uac2_chip *uac2; /* parent chip */
>>> -       bool ep_enabled; /* if the ep is enabled */
>>> -       /* Size of the ring buffer */
>>> -       size_t dma_bytes;
>>> -       unsigned char *dma_area;
>>> -
>>> -       struct snd_pcm_substream *ss;
>>> -
>>> -       /* Ring buffer */
>>> -       ssize_t hw_ptr;
>>> -
>>> -       void *rbuf;
>>> -
>>> -       size_t period_size;
>>> -
>>> -       unsigned max_psize;
>>> -       struct uac2_req *ureq;
>>> -
>>> -       spinlock_t lock;
>>> -};
>>> -
>>> -struct snd_uac2_chip {
>>> -       struct uac2_rtd_params p_prm;
>>> -       struct uac2_rtd_params c_prm;
>>> -
>>> -       struct snd_card *card;
>>> -       struct snd_pcm *pcm;
>>> -
>>> -       /* timekeeping for the playback endpoint */
>>> -       unsigned int p_interval;
>>> -       unsigned int p_residue;
>>> -
>>> -       /* pre-calculated values for playback iso completion */
>>> -       unsigned int p_pktsize;
>>> -       unsigned int p_pktsize_residue;
>>> -       unsigned int p_framesize;
>>> +struct f_uac2 {
>>> +       struct g_audio g_audio;
>>> +       u8 ac_intf, as_in_intf, as_out_intf;
>>> +       u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
>>>  };
>>>
>>> -#define BUFF_SIZE_MAX  (PAGE_SIZE * 16)
>>> -#define PRD_SIZE_MAX   PAGE_SIZE
>>> -#define MIN_PERIODS    4
>>> -
>>> -static struct snd_pcm_hardware uac2_pcm_hardware = {
>>> -       .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
>>> -                | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
>>> -                | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
>>> -       .rates = SNDRV_PCM_RATE_CONTINUOUS,
>>> -       .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
>>> -       .buffer_bytes_max = BUFF_SIZE_MAX,
>>> -       .period_bytes_max = PRD_SIZE_MAX,
>>> -       .periods_min = MIN_PERIODS,
>>> -};
>>> -
>>> -struct audio_dev {
>>> -       u8 ac_intf, ac_alt;
>>> -       u8 as_out_intf, as_out_alt;
>>> -       u8 as_in_intf, as_in_alt;
>>> -
>>> -       struct usb_ep *in_ep, *out_ep;
>>> -       struct usb_function func;
>>> -       struct usb_gadget *gadget;
>>> -
>>> -       /* The ALSA Sound Card it represents on the USB-Client side */
>>> -       struct snd_uac2_chip uac2;
>>> -};
>>> -
>>> -static inline
>>> -struct audio_dev *func_to_agdev(struct usb_function *f)
>>> +static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
>>>  {
>>> -       return container_of(f, struct audio_dev, func);
>>> +       return container_of(f, struct f_uac2, g_audio.func);
>>>  }
>>>
>>>  static inline
>>> -struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
>>> -{
>>> -       return container_of(u, struct audio_dev, uac2);
>>> -}
>>> -
>>> -static inline
>>> -struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
>>> +struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
>>>  {
>>>         return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
>>>  }
>>>
>>> -static inline
>>> -uint num_channels(uint chanmask)
>>> -{
>>> -       uint num = 0;
>>> -
>>> -       while (chanmask) {
>>> -               num += (chanmask & 1);
>>> -               chanmask >>= 1;
>>> -       }
>>> -
>>> -       return num;
>>> -}
>>> -
>>> -static void
>>> -agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
>>> -{
>>> -       unsigned pending;
>>> -       unsigned long flags;
>>> -       unsigned int hw_ptr;
>>> -       bool update_alsa = false;
>>> -       int status = req->status;
>>> -       struct uac2_req *ur = req->context;
>>> -       struct snd_pcm_substream *substream;
>>> -       struct uac2_rtd_params *prm = ur->pp;
>>> -       struct snd_uac2_chip *uac2 = prm->uac2;
>>> -
>>> -       /* i/f shutting down */
>>> -       if (!prm->ep_enabled || req->status == -ESHUTDOWN)
>>> -               return;
>>> -
>>> -       /*
>>> -        * We can't really do much about bad xfers.
>>> -        * Afterall, the ISOCH xfers could fail legitimately.
>>> -        */
>>> -       if (status)
>>> -               pr_debug("%s: iso_complete status(%d) %d/%d\n",
>>> -                       __func__, status, req->actual, req->length);
>>> -
>>> -       substream = prm->ss;
>>> -
>>> -       /* Do nothing if ALSA isn't active */
>>> -       if (!substream)
>>> -               goto exit;
>>> -
>>> -       spin_lock_irqsave(&prm->lock, flags);
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>>> -               /*
>>> -                * For each IN packet, take the quotient of the current data
>>> -                * rate and the endpoint's interval as the base packet size.
>>> -                * If there is a residue from this division, add it to the
>>> -                * residue accumulator.
>>> -                */
>>> -               req->length = uac2->p_pktsize;
>>> -               uac2->p_residue += uac2->p_pktsize_residue;
>>> -
>>> -               /*
>>> -                * Whenever there are more bytes in the accumulator than we
>>> -                * need to add one more sample frame, increase this packet's
>>> -                * size and decrease the accumulator.
>>> -                */
>>> -               if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
>>> -                       req->length += uac2->p_framesize;
>>> -                       uac2->p_residue -= uac2->p_framesize *
>>> -                                          uac2->p_interval;
>>> -               }
>>> -
>>> -               req->actual = req->length;
>>> -       }
>>> -
>>> -       pending = prm->hw_ptr % prm->period_size;
>>> -       pending += req->actual;
>>> -       if (pending >= prm->period_size)
>>> -               update_alsa = true;
>>> -
>>> -       hw_ptr = prm->hw_ptr;
>>> -       prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
>>> -
>>> -       spin_unlock_irqrestore(&prm->lock, flags);
>>> -
>>> -       /* Pack USB load in ALSA ring buffer */
>>> -       pending = prm->dma_bytes - hw_ptr;
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>>> -               if (unlikely(pending < req->actual)) {
>>> -                       memcpy(req->buf, prm->dma_area + hw_ptr, pending);
>>> -                       memcpy(req->buf + pending, prm->dma_area,
>>> -                              req->actual - pending);
>>> -               } else {
>>> -                       memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
>>> -               }
>>> -       } else {
>>> -               if (unlikely(pending < req->actual)) {
>>> -                       memcpy(prm->dma_area + hw_ptr, req->buf, pending);
>>> -                       memcpy(prm->dma_area, req->buf + pending,
>>> -                              req->actual - pending);
>>> -               } else {
>>> -                       memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
>>> -               }
>>> -       }
>>> -
>>> -exit:
>>> -       if (usb_ep_queue(ep, req, GFP_ATOMIC))
>>> -               dev_err(uac2->card->dev, "%d Error!\n", __LINE__);
>>> -
>>> -       if (update_alsa)
>>> -               snd_pcm_period_elapsed(substream);
>>> -
>>> -       return;
>>> -}
>>> -
>>> -static int
>>> -uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>>> -       struct audio_dev *agdev = uac2_to_agdev(uac2);
>>> -       struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
>>> -       struct uac2_rtd_params *prm;
>>> -       unsigned long flags;
>>> -       int err = 0;
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>>> -               prm = &uac2->p_prm;
>>> -       else
>>> -               prm = &uac2->c_prm;
>>> -
>>> -       spin_lock_irqsave(&prm->lock, flags);
>>> -
>>> -       /* Reset */
>>> -       prm->hw_ptr = 0;
>>> -
>>> -       switch (cmd) {
>>> -       case SNDRV_PCM_TRIGGER_START:
>>> -       case SNDRV_PCM_TRIGGER_RESUME:
>>> -               prm->ss = substream;
>>> -               break;
>>> -       case SNDRV_PCM_TRIGGER_STOP:
>>> -       case SNDRV_PCM_TRIGGER_SUSPEND:
>>> -               prm->ss = NULL;
>>> -               break;
>>> -       default:
>>> -               err = -EINVAL;
>>> -       }
>>> -
>>> -       spin_unlock_irqrestore(&prm->lock, flags);
>>> -
>>> -       /* Clear buffer after Play stops */
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
>>> -               memset(prm->rbuf, 0, prm->max_psize * uac2_opts->req_number);
>>> -
>>> -       return err;
>>> -}
>>> -
>>> -static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>>> -       struct uac2_rtd_params *prm;
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>>> -               prm = &uac2->p_prm;
>>> -       else
>>> -               prm = &uac2->c_prm;
>>> -
>>> -       return bytes_to_frames(substream->runtime, prm->hw_ptr);
>>> -}
>>> -
>>> -static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
>>> -                              struct snd_pcm_hw_params *hw_params)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>>> -       struct uac2_rtd_params *prm;
>>> -       int err;
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>>> -               prm = &uac2->p_prm;
>>> -       else
>>> -               prm = &uac2->c_prm;
>>> -
>>> -       err = snd_pcm_lib_malloc_pages(substream,
>>> -                                       params_buffer_bytes(hw_params));
>>> -       if (err >= 0) {
>>> -               prm->dma_bytes = substream->runtime->dma_bytes;
>>> -               prm->dma_area = substream->runtime->dma_area;
>>> -               prm->period_size = params_period_bytes(hw_params);
>>> -       }
>>> -
>>> -       return err;
>>> -}
>>> -
>>> -static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>>> -       struct uac2_rtd_params *prm;
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
>>> -               prm = &uac2->p_prm;
>>> -       else
>>> -               prm = &uac2->c_prm;
>>> -
>>> -       prm->dma_area = NULL;
>>> -       prm->dma_bytes = 0;
>>> -       prm->period_size = 0;
>>> -
>>> -       return snd_pcm_lib_free_pages(substream);
>>> -}
>>> -
>>> -static int uac2_pcm_open(struct snd_pcm_substream *substream)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
>>> -       struct snd_pcm_runtime *runtime = substream->runtime;
>>> -       struct audio_dev *audio_dev;
>>> -       struct f_uac2_opts *opts;
>>> -       int p_ssize, c_ssize;
>>> -       int p_srate, c_srate;
>>> -       int p_chmask, c_chmask;
>>> -
>>> -       audio_dev = uac2_to_agdev(uac2);
>>> -       opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
>>> -       p_ssize = opts->p_ssize;
>>> -       c_ssize = opts->c_ssize;
>>> -       p_srate = opts->p_srate;
>>> -       c_srate = opts->c_srate;
>>> -       p_chmask = opts->p_chmask;
>>> -       c_chmask = opts->c_chmask;
>>> -       uac2->p_residue = 0;
>>> -
>>> -       runtime->hw = uac2_pcm_hardware;
>>> -
>>> -       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
>>> -               spin_lock_init(&uac2->p_prm.lock);
>>> -               runtime->hw.rate_min = p_srate;
>>> -               switch (p_ssize) {
>>> -               case 3:
>>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
>>> -                       break;
>>> -               case 4:
>>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
>>> -                       break;
>>> -               default:
>>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
>>> -                       break;
>>> -               }
>>> -               runtime->hw.channels_min = num_channels(p_chmask);
>>> -               runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
>>> -                                               / runtime->hw.periods_min;
>>> -       } else {
>>> -               spin_lock_init(&uac2->c_prm.lock);
>>> -               runtime->hw.rate_min = c_srate;
>>> -               switch (c_ssize) {
>>> -               case 3:
>>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
>>> -                       break;
>>> -               case 4:
>>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
>>> -                       break;
>>> -               default:
>>> -                       runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
>>> -                       break;
>>> -               }
>>> -               runtime->hw.channels_min = num_channels(c_chmask);
>>> -               runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
>>> -                                               / runtime->hw.periods_min;
>>> -       }
>>> -
>>> -       runtime->hw.rate_max = runtime->hw.rate_min;
>>> -       runtime->hw.channels_max = runtime->hw.channels_min;
>>> -
>>> -       snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
>>> -
>>> -       return 0;
>>> -}
>>> -
>>> -/* ALSA cries without these function pointers */
>>> -static int uac2_pcm_null(struct snd_pcm_substream *substream)
>>> -{
>>> -       return 0;
>>> -}
>>> -
>>> -static struct snd_pcm_ops uac2_pcm_ops = {
>>> -       .open = uac2_pcm_open,
>>> -       .close = uac2_pcm_null,
>>> -       .ioctl = snd_pcm_lib_ioctl,
>>> -       .hw_params = uac2_pcm_hw_params,
>>> -       .hw_free = uac2_pcm_hw_free,
>>> -       .trigger = uac2_pcm_trigger,
>>> -       .pointer = uac2_pcm_pointer,
>>> -       .prepare = uac2_pcm_null,
>>> -};
>>> -
>>> -static int snd_uac2_probe(struct audio_dev *audio_dev)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = &audio_dev->uac2;
>>> -       struct snd_card *card;
>>> -       struct snd_pcm *pcm;
>>> -       struct f_uac2_opts *opts;
>>> -       int err;
>>> -       int p_chmask, c_chmask;
>>> -
>>> -       opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
>>> -       p_chmask = opts->p_chmask;
>>> -       c_chmask = opts->c_chmask;
>>> -
>>> -       /* Choose any slot, with no id */
>>> -       err = snd_card_new(&audio_dev->gadget->dev,
>>> -                       -1, NULL, THIS_MODULE, 0, &card);
>>> -       if (err < 0)
>>> -               return err;
>>> -
>>> -       uac2->card = card;
>>> -
>>> -       /*
>>> -        * Create first PCM device
>>> -        * Create a substream only for non-zero channel streams
>>> -        */
>>> -       err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
>>> -                              p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
>>> -       if (err < 0)
>>> -               goto snd_fail;
>>> -
>>> -       strcpy(pcm->name, "UAC2 PCM");
>>> -       pcm->private_data = uac2;
>>> -
>>> -       uac2->pcm = pcm;
>>> -
>>> -       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
>>> -       snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
>>> -
>>> -       strcpy(card->driver, "UAC2_Gadget");
>>> -       strcpy(card->shortname, "UAC2_Gadget");
>>> -       sprintf(card->longname, "UAC2_Gadget %i", card->dev->id);
>>> -
>>> -       snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
>>> -               snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
>>> -
>>> -       err = snd_card_register(card);
>>> -
>>> -       if (!err)
>>> -               return 0;
>>> -
>>> -snd_fail:
>>> -       snd_card_free(card);
>>> -
>>> -       uac2->pcm = NULL;
>>> -       uac2->card = NULL;
>>> -
>>> -       return err;
>>> -}
>>> -
>>> -static int snd_uac2_remove(struct audio_dev *audio_dev)
>>> -{
>>> -       struct snd_card *card = audio_dev->uac2.card;
>>> -
>>> -       if (card)
>>> -               return snd_card_free(card);
>>> -
>>> -       return 0;
>>> -}
>>> -
>>> -
>>>  /* --------- USB Function Interface ------------- */
>>>
>>>  enum {
>>> @@ -886,32 +451,6 @@ struct cntrl_range_lay3 {
>>>         __u32   dRES;
>>>  } __packed;
>>>
>>> -static inline void
>>> -free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
>>> -{
>>> -       struct snd_uac2_chip *uac2 = prm->uac2;
>>> -       struct audio_dev *agdev = uac2_to_agdev(uac2);
>>> -       struct f_uac2_opts *uac2_opts = agdev_to_uac2_opts(agdev);
>>> -       int i;
>>> -
>>> -       if (!prm->ep_enabled)
>>> -               return;
>>> -
>>> -       prm->ep_enabled = false;
>>> -
>>> -       for (i = 0; i < uac2_opts->req_number; i++) {
>>> -               if (prm->ureq[i].req) {
>>> -                       usb_ep_dequeue(ep, prm->ureq[i].req);
>>> -                       usb_ep_free_request(ep, prm->ureq[i].req);
>>> -                       prm->ureq[i].req = NULL;
>>> -               }
>>> -       }
>>> -
>>> -       if (usb_ep_disable(ep))
>>> -               dev_err(uac2->card->dev,
>>> -                       "%s:%d Error!\n", __func__, __LINE__);
>>> -}
>>> -
>>>  static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>         struct usb_endpoint_descriptor *ep_desc,
>>>         unsigned int factor, bool is_playback)
>>> @@ -938,12 +477,11 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>  static int
>>>  afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
>>>  {
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
>>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>>         struct usb_composite_dev *cdev = cfg->cdev;
>>>         struct usb_gadget *gadget = cdev->gadget;
>>>         struct device *dev = &gadget->dev;
>>> -       struct uac2_rtd_params *prm;
>>>         struct f_uac2_opts *uac2_opts;
>>>         struct usb_string *us;
>>>         int ret;
>>> @@ -990,8 +528,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>                 return ret;
>>>         }
>>>         std_ac_if_desc.bInterfaceNumber = ret;
>>> -       agdev->ac_intf = ret;
>>> -       agdev->ac_alt = 0;
>>> +       uac2->ac_intf = ret;
>>> +       uac2->ac_alt = 0;
>>>
>>>         ret = usb_interface_id(cfg, fn);
>>>         if (ret < 0) {
>>> @@ -1000,8 +538,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>         }
>>>         std_as_out_if0_desc.bInterfaceNumber = ret;
>>>         std_as_out_if1_desc.bInterfaceNumber = ret;
>>> -       agdev->as_out_intf = ret;
>>> -       agdev->as_out_alt = 0;
>>> +       uac2->as_out_intf = ret;
>>> +       uac2->as_out_alt = 0;
>>>
>>>         ret = usb_interface_id(cfg, fn);
>>>         if (ret < 0) {
>>> @@ -1010,8 +548,8 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>         }
>>>         std_as_in_if0_desc.bInterfaceNumber = ret;
>>>         std_as_in_if1_desc.bInterfaceNumber = ret;
>>> -       agdev->as_in_intf = ret;
>>> -       agdev->as_in_alt = 0;
>>> +       uac2->as_in_intf = ret;
>>> +       uac2->as_in_alt = 0;
>>>
>>>         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
>>>         if (!agdev->out_ep) {
>>> @@ -1025,15 +563,17 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>                 return ret;
>>>         }
>>>
>>> -       uac2->p_prm.uac2 = uac2;
>>> -       uac2->c_prm.uac2 = uac2;
>>> -
>>>         /* Calculate wMaxPacketSize according to audio bandwidth */
>>>         set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
>>>         set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
>>>         set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
>>>         set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
>>>
>>> +       agdev->in_ep_maxpsize = max(fs_epin_desc.wMaxPacketSize,
>>> +                                       hs_epin_desc.wMaxPacketSize);
>>> +       agdev->out_ep_maxpsize = max(fs_epout_desc.wMaxPacketSize,
>>> +                                       hs_epout_desc.wMaxPacketSize);
>>> +
>>>         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
>>>         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
>>>
>>> @@ -1044,46 +584,18 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>
>>>         agdev->gadget = gadget;
>>>
>>> -       prm = &agdev->uac2.c_prm;
>>> -       prm->max_psize = hs_epout_desc.wMaxPacketSize;
>>> -       prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
>>> -                       GFP_KERNEL);
>>> -       if (!prm->ureq) {
>>> -               ret = -ENOMEM;
>>> -               goto err_free_descs;
>>> -       }
>>> -       prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
>>> -       if (!prm->rbuf) {
>>> -               prm->max_psize = 0;
>>> -               ret = -ENOMEM;
>>> -               goto err_free_descs;
>>> -       }
>>> -
>>> -       prm = &agdev->uac2.p_prm;
>>> -       prm->max_psize = hs_epin_desc.wMaxPacketSize;
>>> -       prm->ureq = kcalloc(uac2_opts->req_number, sizeof(struct uac2_req),
>>> -                       GFP_KERNEL);
>>> -       if (!prm->ureq) {
>>> -               ret = -ENOMEM;
>>> -               goto err_free_descs;
>>> -       }
>>> -       prm->rbuf = kcalloc(uac2_opts->req_number, prm->max_psize, GFP_KERNEL);
>>> -       if (!prm->rbuf) {
>>> -               prm->max_psize = 0;
>>> -               ret = -ENOMEM;
>>> -               goto err_no_memory;
>>> -       }
>>> -
>>> -       ret = snd_uac2_probe(agdev);
>>> +       agdev->params.p_chmask = uac2_opts->p_chmask;
>>> +       agdev->params.p_srate = uac2_opts->p_srate;
>>> +       agdev->params.p_ssize = uac2_opts->p_ssize;
>>> +       agdev->params.c_chmask = uac2_opts->c_chmask;
>>> +       agdev->params.c_srate = uac2_opts->c_srate;
>>> +       agdev->params.c_ssize = uac2_opts->c_ssize;
>>> +       agdev->params.req_number = uac2_opts->req_number;
>>> +       ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
>>>         if (ret)
>>> -               goto err_no_memory;
>>> +               goto err_free_descs;
>>>         return 0;
>>>
>>> -err_no_memory:
>>> -       kfree(agdev->uac2.p_prm.ureq);
>>> -       kfree(agdev->uac2.c_prm.ureq);
>>> -       kfree(agdev->uac2.p_prm.rbuf);
>>> -       kfree(agdev->uac2.c_prm.rbuf);
>>>  err_free_descs:
>>>         usb_free_all_descriptors(fn);
>>>         agdev->gadget = NULL;
>>> @@ -1094,15 +606,10 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>  afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
>>>  {
>>>         struct usb_composite_dev *cdev = fn->config->cdev;
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> -       struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
>>> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
>>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>>         struct usb_gadget *gadget = cdev->gadget;
>>>         struct device *dev = &gadget->dev;
>>> -       struct usb_request *req;
>>> -       struct usb_ep *ep;
>>> -       struct uac2_rtd_params *prm;
>>> -       int req_len, i;
>>> +       int ret = 0;
>>>
>>>         /* No i/f has more than 2 alt settings */
>>>         if (alt > 1) {
>>> @@ -1110,7 +617,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>                 return -EINVAL;
>>>         }
>>>
>>> -       if (intf == agdev->ac_intf) {
>>> +       if (intf == uac2->ac_intf) {
>>>                 /* Control I/f has only 1 AltSetting - 0 */
>>>                 if (alt) {
>>>                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>>> @@ -1119,92 +626,40 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>                 return 0;
>>>         }
>>>
>>> -       if (intf == agdev->as_out_intf) {
>>> -               ep = agdev->out_ep;
>>> -               prm = &uac2->c_prm;
>>> -               config_ep_by_speed(gadget, fn, ep);
>>> -               agdev->as_out_alt = alt;
>>> -               req_len = prm->max_psize;
>>> -       } else if (intf == agdev->as_in_intf) {
>>> -               unsigned int factor, rate;
>>> -               struct usb_endpoint_descriptor *ep_desc;
>>> -
>>> -               ep = agdev->in_ep;
>>> -               prm = &uac2->p_prm;
>>> -               config_ep_by_speed(gadget, fn, ep);
>>> -               agdev->as_in_alt = alt;
>>> -
>>> -               /* pre-calculate the playback endpoint's interval */
>>> -               if (gadget->speed == USB_SPEED_FULL) {
>>> -                       ep_desc = &fs_epin_desc;
>>> -                       factor = 1000;
>>> -               } else {
>>> -                       ep_desc = &hs_epin_desc;
>>> -                       factor = 8000;
>>> -               }
>>> -
>>> -               /* pre-compute some values for iso_complete() */
>>> -               uac2->p_framesize = opts->p_ssize *
>>> -                                   num_channels(opts->p_chmask);
>>> -               rate = opts->p_srate * uac2->p_framesize;
>>> -               uac2->p_interval = factor / (1 << (ep_desc->bInterval - 1));
>>> -               uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
>>> -                                       prm->max_psize);
>>> +       if (intf == uac2->as_out_intf) {
>>> +               uac2->as_out_alt = alt;
>>>
>>> -               if (uac2->p_pktsize < prm->max_psize)
>>> -                       uac2->p_pktsize_residue = rate % uac2->p_interval;
>>> +               if (alt)
>>> +                       ret = u_audio_start_capture(&uac2->g_audio);
>>>                 else
>>> -                       uac2->p_pktsize_residue = 0;
>>> +                       u_audio_stop_capture(&uac2->g_audio);
>>> +       } else if (intf == uac2->as_in_intf) {
>>> +               uac2->as_in_alt = alt;
>>>
>>> -               req_len = uac2->p_pktsize;
>>> -               uac2->p_residue = 0;
>>> +               if (alt)
>>> +                       ret = u_audio_start_playback(&uac2->g_audio);
>>> +               else
>>> +                       u_audio_stop_playback(&uac2->g_audio);
>>>         } else {
>>>                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>>>                 return -EINVAL;
>>>         }
>>>
>>> -       if (alt == 0) {
>>> -               free_ep(prm, ep);
>>> -               return 0;
>>> -       }
>>> -
>>> -       prm->ep_enabled = true;
>>> -       usb_ep_enable(ep);
>>> -
>>> -       for (i = 0; i < opts->req_number; i++) {
>>> -               if (!prm->ureq[i].req) {
>>> -                       req = usb_ep_alloc_request(ep, GFP_ATOMIC);
>>> -                       if (req == NULL)
>>> -                               return -ENOMEM;
>>> -
>>> -                       prm->ureq[i].req = req;
>>> -                       prm->ureq[i].pp = prm;
>>> -
>>> -                       req->zero = 0;
>>> -                       req->context = &prm->ureq[i];
>>> -                       req->length = req_len;
>>> -                       req->complete = agdev_iso_complete;
>>> -                       req->buf = prm->rbuf + i * prm->max_psize;
>>> -               }
>>> -
>>> -               if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
>>> -                       dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
>>> -       }
>>> -
>>> -       return 0;
>>> +       return ret;
>>>  }
>>>
>>>  static int
>>>  afunc_get_alt(struct usb_function *fn, unsigned intf)
>>>  {
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> -
>>> -       if (intf == agdev->ac_intf)
>>> -               return agdev->ac_alt;
>>> -       else if (intf == agdev->as_out_intf)
>>> -               return agdev->as_out_alt;
>>> -       else if (intf == agdev->as_in_intf)
>>> -               return agdev->as_in_alt;
>>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>> +
>>> +       if (intf == uac2->ac_intf)
>>> +               return uac2->ac_alt;
>>> +       else if (intf == uac2->as_out_intf)
>>> +               return uac2->as_out_alt;
>>> +       else if (intf == uac2->as_in_intf)
>>> +               return uac2->as_in_alt;
>>>         else
>>>                 dev_err(&agdev->gadget->dev,
>>>                         "%s:%d Invalid Interface %d!\n",
>>> @@ -1216,21 +671,19 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>  static void
>>>  afunc_disable(struct usb_function *fn)
>>>  {
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> -       struct snd_uac2_chip *uac2 = &agdev->uac2;
>>> -
>>> -       free_ep(&uac2->p_prm, agdev->in_ep);
>>> -       agdev->as_in_alt = 0;
>>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>>
>>> -       free_ep(&uac2->c_prm, agdev->out_ep);
>>> -       agdev->as_out_alt = 0;
>>> +       uac2->as_in_alt = 0;
>>> +       uac2->as_out_alt = 0;
>>> +       u_audio_stop_capture(&uac2->g_audio);
>>> +       u_audio_stop_playback(&uac2->g_audio);
>>>  }
>>>
>>>  static int
>>>  in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>>  {
>>>         struct usb_request *req = fn->config->cdev->req;
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>>         struct f_uac2_opts *opts;
>>>         u16 w_length = le16_to_cpu(cr->wLength);
>>>         u16 w_index = le16_to_cpu(cr->wIndex);
>>> @@ -1240,7 +693,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>         int value = -EOPNOTSUPP;
>>>         int p_srate, c_srate;
>>>
>>> -       opts = agdev_to_uac2_opts(agdev);
>>> +       opts = g_audio_to_uac2_opts(agdev);
>>>         p_srate = opts->p_srate;
>>>         c_srate = opts->c_srate;
>>>
>>> @@ -1271,7 +724,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>  in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>>  {
>>>         struct usb_request *req = fn->config->cdev->req;
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>>         struct f_uac2_opts *opts;
>>>         u16 w_length = le16_to_cpu(cr->wLength);
>>>         u16 w_index = le16_to_cpu(cr->wIndex);
>>> @@ -1282,7 +735,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>         int value = -EOPNOTSUPP;
>>>         int p_srate, c_srate;
>>>
>>> -       opts = agdev_to_uac2_opts(agdev);
>>> +       opts = g_audio_to_uac2_opts(agdev);
>>>         p_srate = opts->p_srate;
>>>         c_srate = opts->c_srate;
>>>
>>> @@ -1336,11 +789,12 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>  static int
>>>  setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>>  {
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> +       struct f_uac2 *uac2 = func_to_uac2(fn);
>>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>>         u16 w_index = le16_to_cpu(cr->wIndex);
>>>         u8 intf = w_index & 0xff;
>>>
>>> -       if (intf != agdev->ac_intf) {
>>> +       if (intf != uac2->ac_intf) {
>>>                 dev_err(&agdev->gadget->dev,
>>>                         "%s:%d Error!\n", __func__, __LINE__);
>>>                 return -EOPNOTSUPP;
>>> @@ -1358,7 +812,7 @@ static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
>>>  afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
>>>  {
>>>         struct usb_composite_dev *cdev = fn->config->cdev;
>>> -       struct audio_dev *agdev = func_to_agdev(fn);
>>> +       struct g_audio *agdev = func_to_g_audio(fn);
>>>         struct usb_request *req = cdev->req;
>>>         u16 w_length = le16_to_cpu(cr->wLength);
>>>         int value = -EOPNOTSUPP;
>>> @@ -1504,10 +958,10 @@ static struct usb_function_instance *afunc_alloc_inst(void)
>>>
>>>  static void afunc_free(struct usb_function *f)
>>>  {
>>> -       struct audio_dev *agdev;
>>> +       struct g_audio *agdev;
>>>         struct f_uac2_opts *opts;
>>>
>>> -       agdev = func_to_agdev(f);
>>> +       agdev = func_to_g_audio(f);
>>>         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
>>>         kfree(agdev);
>>>         mutex_lock(&opts->lock);
>>> @@ -1517,17 +971,9 @@ static void afunc_free(struct usb_function *f)
>>>
>>>  static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
>>>  {
>>> -       struct audio_dev *agdev = func_to_agdev(f);
>>> -       struct uac2_rtd_params *prm;
>>> -
>>> -       snd_uac2_remove(agdev);
>>> -
>>> -       prm = &agdev->uac2.p_prm;
>>> -       kfree(prm->rbuf);
>>> +       struct g_audio *agdev = func_to_g_audio(f);
>>>
>>> -       prm = &agdev->uac2.c_prm;
>>> -       kfree(prm->rbuf);
>>> -       kfree(prm->ureq);
>>> +       g_audio_cleanup(agdev);
>>>         usb_free_all_descriptors(f);
>>>
>>>         agdev->gadget = NULL;
>>> @@ -1535,11 +981,11 @@ static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
>>>
>>>  static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
>>>  {
>>> -       struct audio_dev *agdev;
>>> +       struct f_uac2   *uac2;
>>>         struct f_uac2_opts *opts;
>>>
>>> -       agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
>>> -       if (agdev == NULL)
>>> +       uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
>>> +       if (uac2 == NULL)
>>>                 return ERR_PTR(-ENOMEM);
>>>
>>>         opts = container_of(fi, struct f_uac2_opts, func_inst);
>>> @@ -1547,19 +993,20 @@ static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
>>>         ++opts->refcnt;
>>>         mutex_unlock(&opts->lock);
>>>
>>> -       agdev->func.name = "uac2_func";
>>> -       agdev->func.bind = afunc_bind;
>>> -       agdev->func.unbind = afunc_unbind;
>>> -       agdev->func.set_alt = afunc_set_alt;
>>> -       agdev->func.get_alt = afunc_get_alt;
>>> -       agdev->func.disable = afunc_disable;
>>> -       agdev->func.setup = afunc_setup;
>>> -       agdev->func.free_func = afunc_free;
>>> +       uac2->g_audio.func.name = "uac2_func";
>>> +       uac2->g_audio.func.bind = afunc_bind;
>>> +       uac2->g_audio.func.unbind = afunc_unbind;
>>> +       uac2->g_audio.func.set_alt = afunc_set_alt;
>>> +       uac2->g_audio.func.get_alt = afunc_get_alt;
>>> +       uac2->g_audio.func.disable = afunc_disable;
>>> +       uac2->g_audio.func.setup = afunc_setup;
>>> +       uac2->g_audio.func.free_func = afunc_free;
>>>
>>> -       return &agdev->func;
>>> +       return &uac2->g_audio.func;
>>>  }
>>>
>>>  DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
>>>  MODULE_LICENSE("GPL");
>>>  MODULE_AUTHOR("Yadwinder Singh");
>>>  MODULE_AUTHOR("Jaswinder Singh");
>>> +MODULE_AUTHOR("Ruslan Bilovol");
>>>
>> drivers/usb/gadget/function/f_uac2.c  | 721 ++++------------------------------
>>
>> Basically you move out ALSA sound card implementation and  %s/agdev/uac2/
>> I am not sure churn warrants a MODULE_AUTHOR. People have made far
>> more important contribution to the UAC2,
>
> Yes, I added it after cumulative effect of this patch and patch 1/3
> where I removed  platform driver/device creation from f_uac2.
> I haven't find any rules on this and just counted changed lines,
> however in this particular case it's better to use something
> like MODULE_CLEANER(). Just joking :)
>
> I'll remove this line then.
>
Thanks, that will be fair to all.

>>
>>
>>> diff --git a/drivers/usb/gadget/function/u_audio.c b/drivers/usb/gadget/function/u_audio.c
>>> new file mode 100644
>>> index 0000000..8ee65b8
>>> --- /dev/null
>>> +++ b/drivers/usb/gadget/function/u_audio.c
>>> @@ -0,0 +1,661 @@
>>> +/*
>>> + * u_audio.c -- interface to USB gadget "ALSA sound card" utilities
>>> + *
>>> + * Copyright (C) 2016
>>> + * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>>> + *
>>> + * Based on f_uac2.c which is:
>>> + *    Copyright (C) 2011
>>> + *    Yadwinder Singh (yadi.brar01@gmail.com)
>>> + *    Jaswinder Singh (jaswinder.singh@linaro.org)
>>> + *
>> Again this is not "based on", rather where you paste the code you cut
>> from f_uac2.c
>> Of course you also pad it with minor changes to make it useful to your
>> uac1 code. I am not happy with losing copyright on the sound card
>> implementation for the UAC drivers.
>
> I don't remember why I wrote it as "based on" back in 2016,
> probably looking into another patches as example. As per my
> understanding, "based on" + your name in Copyright means
> that you still continue to hold copyright on the sound card
> implementation (otherwise why mention it?).
>
I don't think copyright spreads by inspiration :)

But seriously, we have to be careful if we set a precedence here. You
write some important piece of code and assert copyright over it.
Sometime later someone finds a reason to move that code to a new file
and adds his/her copyright while relegating you to just "inspiration".
You can contest the code was your copyright originally but is surely
tougher than having the code clearly state that fact.

> However I'm not a lawyer so can't say for sure.
> Will change this description in next patchset to make it clear,
> so you won't loose your copyright.
>
Thank you.

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core
  2017-06-02  9:34   ` Felipe Balbi
@ 2017-06-02 21:11     ` Ruslan Bilovol
  0 siblings, 0 replies; 17+ messages in thread
From: Ruslan Bilovol @ 2017-06-02 21:11 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

Hi Felipe,

On Fri, Jun 2, 2017 at 12:34 PM, Felipe Balbi <balbi@kernel.org> wrote:
>
> Hi,
>
> Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
>> Abstract the peripheral side ALSA sound card code from
>> the f_uac2 function into a component that can be called
>> by various functions, so the various flavors can be split
>> apart and selectively reused.
>>
>> Visible changes:
>>  - add uac_params structure to pass audio paramteres for
>>    g_audio_setup
>>  - make ALSA sound card's name configurable
>>  - add [in/out]_ep_maxpsize
>>  - allocate snd_uac_chip structure during g_audio_setup
>>  - add u_audio_[start/stop]_[capture/playback] functions
>>
>> Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
>
> this doesn't apply on testing/next, care to rebase?
>

sure, I'll rebase it and address comments from Jassi

Regards,
Ruslan

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 0/3] USB Audio Gadget refactoring
  2017-06-02  9:42 ` [PATCH v4 0/3] USB Audio Gadget refactoring Felipe Balbi
@ 2017-06-02 21:36   ` Ruslan Bilovol
  2017-06-05  9:22     ` Felipe Balbi
  0 siblings, 1 reply; 17+ messages in thread
From: Ruslan Bilovol @ 2017-06-02 21:36 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

Hi,

On Fri, Jun 2, 2017 at 12:42 PM, Felipe Balbi <balbi@kernel.org> wrote:
>
> Hi,
>
> Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
>> I came to this patch series when wanted to do two things:
>>  - use UAC1 as virtual ALSA sound card on gadget side,
>>    just like UAC2 is used so it's possible to do rate
>>    resampling
>>  - have both playback/capture support in UAC1
>>
>> Since I wanted to have same behavior for both UAC1/UAC2,
>> obviously I've got an utility part (u_audio.c) for
>> virtual ALSA sound card handling like we have
>> for ethernet(u_ether) or serial(u_serial) functions.
>> Function-specific parts (f_uac1/f_uac2) became almost
>> as storage for class-specific USB descriptors, some
>> boilerplate for configfs, binding and few USB
>> config request handling.
>>
>> Originally in RFC [1] I've posted before, there was
>> major change to f_uac1 after that it couldn't do
>> direct play to existing ALSA sound card anymore,
>> representing audio on gadget side as virtual
>> ALSA sound card where audio streams are simply
>> sinked to and sourced from it, so it may break
>> current usecase for some people (and that's why
>> it was RFC).
>>
>> During RFC discussion, it was agreed to not touch
>> existing f_uac1 implementation and create new one
>> instead. This patchset (v4) introduced new function
>> named f_uac1_acard and doesn't touch current f_uac1
>> implementation, so people still can use old behavior
>
> Do you have a pointer to the original RFC discussion where this was
> discussed? If we really *must* keep the old implementation, I would
> rather rename that to f_uac1_legacy. Still, I find it unlikely that
> anybody will care about the old implementation.

It is on LKML (which is down for me) [1] or alternative archive [2]

>
>> Now, it's possible to use existing user-space
>> applications for audio routing between Audio Gadget
>> and real sound card. I personally use alsaloop tool
>> from alsautils and have ability to create PCM
>> loopback between two different ALSA cards using
>> rate resampling, which was not possible with previous
>> "direct play to ALSA card" approach in f_uac1.
>
> this is really good result and will actually make it a lot easier for
> testing things out.
>
>> While here, also dropped redundant platform
>> driver/device creation in f_uac2 driver (as well as
>> didn't add "never implemented" volume/mute functionality
>> in f_uac1 to f_uac1_acard) that made this work even
>> easier to do.
>>
>> This series is tested with both legacy g_audio.ko and
>> modern configfs approaches under Ubuntu 14.04 (UAC1 and
>> UAC2) and under Windows7 x64 (UAC1 only) having
>> perfect results in all cases.
>>
>> Comments, testing are welcome.
>>
>> v4 changes:
>>  - renamed f_uac1_newapi to f_uac1_acard that is
>>    more meaningful
>
> I really don't get why you wanna keep both f_uac1 and f_uac1_acard. Why
> do we need to maintain the old uac1 implementation? Why two separate
> files?

In first RFC ([1],[2]) I did exactly what you wrote here (removed
old uac1 implementation and replaced it by new one) but got feedback
that it will break things for existing f_uac1 legacy users and it's better to
have separate implementation.

I'm OK with dropping legacy f_uac1 implementation.

Another idea I was thinking about is to implement simple in-kernel
driver which will do the same as existing alsaloop tool userspace
tool does (so legacy users will need to load two kernel modules
and get same functionality). But this seems to be a wrong way,
since It known that Linux kernel community doesn't like to take drivers
with same functionality as existing userspace tools already have.

So bottom line: since I'm not a legacy f_uac1 user, there is no
difference for me how to handle it - remove legacy f_uac1 completely,
rename it to f_uac1_legacy or add separate f_uac1_acard function.

So if dropping of legacy f_uac1 implementation is OK for you,
I can do it quickly in next patchset.

[1] https://lkml.org/lkml/2016/5/23/649
[2] https://marc.info/?t=146404758800001&r=1&w=4

Regards,
Ruslan

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 0/3] USB Audio Gadget refactoring
  2017-06-02 21:36   ` Ruslan Bilovol
@ 2017-06-05  9:22     ` Felipe Balbi
  2017-06-06  7:44       ` Greg KH
  0 siblings, 1 reply; 17+ messages in thread
From: Felipe Balbi @ 2017-06-05  9:22 UTC (permalink / raw)
  To: Ruslan Bilovol, Greg KH, Alan Stern
  Cc: Daniel Mack, Jassi Brar, Clemens Ladisch, Jonathan Corbet,
	Greg Kroah-Hartman, Peter Chen, Julian Scheel, linux-usb,
	linux-doc, linux-kernel

[-- Attachment #1: Type: text/plain, Size: 4564 bytes --]


Hi,

Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
>> Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
>>> I came to this patch series when wanted to do two things:
>>>  - use UAC1 as virtual ALSA sound card on gadget side,
>>>    just like UAC2 is used so it's possible to do rate
>>>    resampling
>>>  - have both playback/capture support in UAC1
>>>
>>> Since I wanted to have same behavior for both UAC1/UAC2,
>>> obviously I've got an utility part (u_audio.c) for
>>> virtual ALSA sound card handling like we have
>>> for ethernet(u_ether) or serial(u_serial) functions.
>>> Function-specific parts (f_uac1/f_uac2) became almost
>>> as storage for class-specific USB descriptors, some
>>> boilerplate for configfs, binding and few USB
>>> config request handling.
>>>
>>> Originally in RFC [1] I've posted before, there was
>>> major change to f_uac1 after that it couldn't do
>>> direct play to existing ALSA sound card anymore,
>>> representing audio on gadget side as virtual
>>> ALSA sound card where audio streams are simply
>>> sinked to and sourced from it, so it may break
>>> current usecase for some people (and that's why
>>> it was RFC).
>>>
>>> During RFC discussion, it was agreed to not touch
>>> existing f_uac1 implementation and create new one
>>> instead. This patchset (v4) introduced new function
>>> named f_uac1_acard and doesn't touch current f_uac1
>>> implementation, so people still can use old behavior
>>
>> Do you have a pointer to the original RFC discussion where this was
>> discussed? If we really *must* keep the old implementation, I would
>> rather rename that to f_uac1_legacy. Still, I find it unlikely that
>> anybody will care about the old implementation.
>
> It is on LKML (which is down for me) [1] or alternative archive [2]
>
>>
>>> Now, it's possible to use existing user-space
>>> applications for audio routing between Audio Gadget
>>> and real sound card. I personally use alsaloop tool
>>> from alsautils and have ability to create PCM
>>> loopback between two different ALSA cards using
>>> rate resampling, which was not possible with previous
>>> "direct play to ALSA card" approach in f_uac1.
>>
>> this is really good result and will actually make it a lot easier for
>> testing things out.
>>
>>> While here, also dropped redundant platform
>>> driver/device creation in f_uac2 driver (as well as
>>> didn't add "never implemented" volume/mute functionality
>>> in f_uac1 to f_uac1_acard) that made this work even
>>> easier to do.
>>>
>>> This series is tested with both legacy g_audio.ko and
>>> modern configfs approaches under Ubuntu 14.04 (UAC1 and
>>> UAC2) and under Windows7 x64 (UAC1 only) having
>>> perfect results in all cases.
>>>
>>> Comments, testing are welcome.
>>>
>>> v4 changes:
>>>  - renamed f_uac1_newapi to f_uac1_acard that is
>>>    more meaningful
>>
>> I really don't get why you wanna keep both f_uac1 and f_uac1_acard. Why
>> do we need to maintain the old uac1 implementation? Why two separate
>> files?
>
> In first RFC ([1],[2]) I did exactly what you wrote here (removed
> old uac1 implementation and replaced it by new one) but got feedback
> that it will break things for existing f_uac1 legacy users and it's better to
> have separate implementation.
>
> I'm OK with dropping legacy f_uac1 implementation.
>
> Another idea I was thinking about is to implement simple in-kernel
> driver which will do the same as existing alsaloop tool userspace
> tool does (so legacy users will need to load two kernel modules
> and get same functionality). But this seems to be a wrong way,
> since It known that Linux kernel community doesn't like to take drivers
> with same functionality as existing userspace tools already have.
>
> So bottom line: since I'm not a legacy f_uac1 user, there is no
> difference for me how to handle it - remove legacy f_uac1 completely,
> rename it to f_uac1_legacy or add separate f_uac1_acard function.
>
> So if dropping of legacy f_uac1 implementation is OK for you,
> I can do it quickly in next patchset.

Personally, I don't want duplicated functionality and I think the
virtual sound card approach is much better. Then again, removing
functionality we already support is kind of odd.

Greg, Alan, what do you guys think? Do we keep a duplicated function
around or do we just tell people to rely on alsaloop? Personally, I
think we're better off with the flexibility of the virtual sound card,
what's your take?

-- 
balbi

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 0/3] USB Audio Gadget refactoring
  2017-06-05  9:22     ` Felipe Balbi
@ 2017-06-06  7:44       ` Greg KH
  2017-06-06  9:41         ` Felipe Balbi
  0 siblings, 1 reply; 17+ messages in thread
From: Greg KH @ 2017-06-06  7:44 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Ruslan Bilovol, Alan Stern, Daniel Mack, Jassi Brar,
	Clemens Ladisch, Jonathan Corbet, Peter Chen, Julian Scheel,
	linux-usb, linux-doc, linux-kernel

On Mon, Jun 05, 2017 at 12:22:13PM +0300, Felipe Balbi wrote:
> 
> Hi,
> 
> Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
> >> Ruslan Bilovol <ruslan.bilovol@gmail.com> writes:
> >>> I came to this patch series when wanted to do two things:
> >>>  - use UAC1 as virtual ALSA sound card on gadget side,
> >>>    just like UAC2 is used so it's possible to do rate
> >>>    resampling
> >>>  - have both playback/capture support in UAC1
> >>>
> >>> Since I wanted to have same behavior for both UAC1/UAC2,
> >>> obviously I've got an utility part (u_audio.c) for
> >>> virtual ALSA sound card handling like we have
> >>> for ethernet(u_ether) or serial(u_serial) functions.
> >>> Function-specific parts (f_uac1/f_uac2) became almost
> >>> as storage for class-specific USB descriptors, some
> >>> boilerplate for configfs, binding and few USB
> >>> config request handling.
> >>>
> >>> Originally in RFC [1] I've posted before, there was
> >>> major change to f_uac1 after that it couldn't do
> >>> direct play to existing ALSA sound card anymore,
> >>> representing audio on gadget side as virtual
> >>> ALSA sound card where audio streams are simply
> >>> sinked to and sourced from it, so it may break
> >>> current usecase for some people (and that's why
> >>> it was RFC).
> >>>
> >>> During RFC discussion, it was agreed to not touch
> >>> existing f_uac1 implementation and create new one
> >>> instead. This patchset (v4) introduced new function
> >>> named f_uac1_acard and doesn't touch current f_uac1
> >>> implementation, so people still can use old behavior
> >>
> >> Do you have a pointer to the original RFC discussion where this was
> >> discussed? If we really *must* keep the old implementation, I would
> >> rather rename that to f_uac1_legacy. Still, I find it unlikely that
> >> anybody will care about the old implementation.
> >
> > It is on LKML (which is down for me) [1] or alternative archive [2]
> >
> >>
> >>> Now, it's possible to use existing user-space
> >>> applications for audio routing between Audio Gadget
> >>> and real sound card. I personally use alsaloop tool
> >>> from alsautils and have ability to create PCM
> >>> loopback between two different ALSA cards using
> >>> rate resampling, which was not possible with previous
> >>> "direct play to ALSA card" approach in f_uac1.
> >>
> >> this is really good result and will actually make it a lot easier for
> >> testing things out.
> >>
> >>> While here, also dropped redundant platform
> >>> driver/device creation in f_uac2 driver (as well as
> >>> didn't add "never implemented" volume/mute functionality
> >>> in f_uac1 to f_uac1_acard) that made this work even
> >>> easier to do.
> >>>
> >>> This series is tested with both legacy g_audio.ko and
> >>> modern configfs approaches under Ubuntu 14.04 (UAC1 and
> >>> UAC2) and under Windows7 x64 (UAC1 only) having
> >>> perfect results in all cases.
> >>>
> >>> Comments, testing are welcome.
> >>>
> >>> v4 changes:
> >>>  - renamed f_uac1_newapi to f_uac1_acard that is
> >>>    more meaningful
> >>
> >> I really don't get why you wanna keep both f_uac1 and f_uac1_acard. Why
> >> do we need to maintain the old uac1 implementation? Why two separate
> >> files?
> >
> > In first RFC ([1],[2]) I did exactly what you wrote here (removed
> > old uac1 implementation and replaced it by new one) but got feedback
> > that it will break things for existing f_uac1 legacy users and it's better to
> > have separate implementation.
> >
> > I'm OK with dropping legacy f_uac1 implementation.
> >
> > Another idea I was thinking about is to implement simple in-kernel
> > driver which will do the same as existing alsaloop tool userspace
> > tool does (so legacy users will need to load two kernel modules
> > and get same functionality). But this seems to be a wrong way,
> > since It known that Linux kernel community doesn't like to take drivers
> > with same functionality as existing userspace tools already have.
> >
> > So bottom line: since I'm not a legacy f_uac1 user, there is no
> > difference for me how to handle it - remove legacy f_uac1 completely,
> > rename it to f_uac1_legacy or add separate f_uac1_acard function.
> >
> > So if dropping of legacy f_uac1 implementation is OK for you,
> > I can do it quickly in next patchset.
> 
> Personally, I don't want duplicated functionality and I think the
> virtual sound card approach is much better. Then again, removing
> functionality we already support is kind of odd.
> 
> Greg, Alan, what do you guys think? Do we keep a duplicated function
> around or do we just tell people to rely on alsaloop? Personally, I
> think we're better off with the flexibility of the virtual sound card,
> what's your take?

If the in-kernel driver will do more things, and we don't break the
existing setups using alsaloop, then I don't see the problem, except
that we now have to maintain two things :)

If you don't mind the maintenance, fine with me...

thanks,

greg k-h

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 0/3] USB Audio Gadget refactoring
  2017-06-06  7:44       ` Greg KH
@ 2017-06-06  9:41         ` Felipe Balbi
  2017-06-06 19:43           ` Ruslan Bilovol
  0 siblings, 1 reply; 17+ messages in thread
From: Felipe Balbi @ 2017-06-06  9:41 UTC (permalink / raw)
  To: Greg KH
  Cc: Ruslan Bilovol, Alan Stern, Daniel Mack, Jassi Brar,
	Clemens Ladisch, Jonathan Corbet, Peter Chen, Julian Scheel,
	linux-usb, linux-doc, linux-kernel

[-- Attachment #1: Type: text/plain, Size: 1814 bytes --]


Hi,

Greg KH <gregkh@linuxfoundation.org> writes:
>> > I'm OK with dropping legacy f_uac1 implementation.
>> >
>> > Another idea I was thinking about is to implement simple in-kernel
>> > driver which will do the same as existing alsaloop tool userspace
>> > tool does (so legacy users will need to load two kernel modules
>> > and get same functionality). But this seems to be a wrong way,
>> > since It known that Linux kernel community doesn't like to take drivers
>> > with same functionality as existing userspace tools already have.
>> >
>> > So bottom line: since I'm not a legacy f_uac1 user, there is no
>> > difference for me how to handle it - remove legacy f_uac1 completely,
>> > rename it to f_uac1_legacy or add separate f_uac1_acard function.
>> >
>> > So if dropping of legacy f_uac1 implementation is OK for you,
>> > I can do it quickly in next patchset.
>> 
>> Personally, I don't want duplicated functionality and I think the
>> virtual sound card approach is much better. Then again, removing
>> functionality we already support is kind of odd.
>> 
>> Greg, Alan, what do you guys think? Do we keep a duplicated function
>> around or do we just tell people to rely on alsaloop? Personally, I
>> think we're better off with the flexibility of the virtual sound card,
>> what's your take?
>
> If the in-kernel driver will do more things, and we don't break the
> existing setups using alsaloop, then I don't see the problem, except
> that we now have to maintain two things :)
>
> If you don't mind the maintenance, fine with me...

Okay, I don't think many will continue to use f_uac1.c. Ruslan, can you
update your series so that current f_uac1.c gets renamed to
f_uac1_legacy.c and you introduce a *new* f_uac1.c instead?

Thanks a lot

-- 
balbi

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 832 bytes --]

^ permalink raw reply	[flat|nested] 17+ messages in thread

* Re: [PATCH v4 0/3] USB Audio Gadget refactoring
  2017-06-06  9:41         ` Felipe Balbi
@ 2017-06-06 19:43           ` Ruslan Bilovol
  0 siblings, 0 replies; 17+ messages in thread
From: Ruslan Bilovol @ 2017-06-06 19:43 UTC (permalink / raw)
  To: Felipe Balbi
  Cc: Greg KH, Alan Stern, Daniel Mack, Jassi Brar, Clemens Ladisch,
	Jonathan Corbet, Peter Chen, Julian Scheel, linux-usb, linux-doc,
	linux-kernel

On Tue, Jun 6, 2017 at 12:41 PM, Felipe Balbi <balbi@kernel.org> wrote:
>
> Hi,
>
> Greg KH <gregkh@linuxfoundation.org> writes:
>>> > I'm OK with dropping legacy f_uac1 implementation.
>>> >
>>> > Another idea I was thinking about is to implement simple in-kernel
>>> > driver which will do the same as existing alsaloop tool userspace
>>> > tool does (so legacy users will need to load two kernel modules
>>> > and get same functionality). But this seems to be a wrong way,
>>> > since It known that Linux kernel community doesn't like to take drivers
>>> > with same functionality as existing userspace tools already have.
>>> >
>>> > So bottom line: since I'm not a legacy f_uac1 user, there is no
>>> > difference for me how to handle it - remove legacy f_uac1 completely,
>>> > rename it to f_uac1_legacy or add separate f_uac1_acard function.
>>> >
>>> > So if dropping of legacy f_uac1 implementation is OK for you,
>>> > I can do it quickly in next patchset.
>>>
>>> Personally, I don't want duplicated functionality and I think the
>>> virtual sound card approach is much better. Then again, removing
>>> functionality we already support is kind of odd.
>>>
>>> Greg, Alan, what do you guys think? Do we keep a duplicated function
>>> around or do we just tell people to rely on alsaloop? Personally, I
>>> think we're better off with the flexibility of the virtual sound card,
>>> what's your take?
>>
>> If the in-kernel driver will do more things, and we don't break the
>> existing setups using alsaloop, then I don't see the problem, except
>> that we now have to maintain two things :)
>>
>> If you don't mind the maintenance, fine with me...
>
> Okay, I don't think many will continue to use f_uac1.c. Ruslan, can you
> update your series so that current f_uac1.c gets renamed to
> f_uac1_legacy.c and you introduce a *new* f_uac1.c instead?

Yes sure, I'll post an updated patch series soon

Best regards,
Ruslan

^ permalink raw reply	[flat|nested] 17+ messages in thread

end of thread, other threads:[~2017-06-06 19:43 UTC | newest]

Thread overview: 17+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2017-05-17 22:37 [PATCH v4 0/3] USB Audio Gadget refactoring Ruslan Bilovol
2017-05-17 22:37 ` [PATCH v4 1/3] usb: gadget: f_uac2: remove platform driver/device creation Ruslan Bilovol
2017-05-17 22:37 ` [PATCH v4 2/3] usb: gadget: f_uac2: split out audio core Ruslan Bilovol
2017-05-22 15:58   ` Jassi Brar
2017-05-29 23:43     ` Ruslan Bilovol
2017-06-02 11:47       ` Jassi Brar
2017-06-02  9:34   ` Felipe Balbi
2017-06-02 21:11     ` Ruslan Bilovol
2017-05-17 22:37 ` [PATCH v4 3/3] usb: gadget: add f_uac1 variant based on a new u_audio api Ruslan Bilovol
2017-05-26 15:52   ` Julian Scheel
2017-05-30  0:07     ` Ruslan Bilovol
2017-06-02  9:42 ` [PATCH v4 0/3] USB Audio Gadget refactoring Felipe Balbi
2017-06-02 21:36   ` Ruslan Bilovol
2017-06-05  9:22     ` Felipe Balbi
2017-06-06  7:44       ` Greg KH
2017-06-06  9:41         ` Felipe Balbi
2017-06-06 19:43           ` Ruslan Bilovol

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).