usb: gadget: add f_uac1 variant based on a new u_audio api
authorRuslan Bilovol <ruslan.bilovol@gmail.com>
Sun, 18 Jun 2017 13:23:54 +0000 (16:23 +0300)
committerFelipe Balbi <felipe.balbi@linux.intel.com>
Mon, 19 Jun 2017 06:22:47 +0000 (09:22 +0300)
This patch adds a new function 'f_uac1'
(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 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 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 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 descriptors naming convention
uses f_uac2 driver naming convention that
makes it more common and meaningful.

Comparing to f_uac1_legacy, the f_uac1 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 functionality, exposed
interface to userspace (virtual ALSA card),
input parameters are so different comparing
to f_uac1_legacy, 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_legacy or f_uac2)

Signed-off-by: Ruslan Bilovol <ruslan.bilovol@gmail.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
Documentation/ABI/testing/configfs-usb-gadget-uac1 [new file with mode: 0644]
Documentation/usb/gadget-testing.txt
drivers/usb/gadget/Kconfig
drivers/usb/gadget/function/Makefile
drivers/usb/gadget/function/f_uac1.c [new file with mode: 0644]
drivers/usb/gadget/function/u_uac1.h [new file with mode: 0644]
drivers/usb/gadget/legacy/Kconfig
drivers/usb/gadget/legacy/audio.c

diff --git a/Documentation/ABI/testing/configfs-usb-gadget-uac1 b/Documentation/ABI/testing/configfs-usb-gadget-uac1
new file mode 100644 (file)
index 0000000..abfe447
--- /dev/null
@@ -0,0 +1,14 @@
+What:          /config/usb-gadget/gadget/functions/uac1.name
+Date:          June 2017
+KernelVersion: 4.14
+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
index ce51d6e4e7d0f7b24a5d96f243e9ae7ae6f4d32b..fbc397d17e98a71be5826362e430863cce837998 100644 (file)
@@ -20,6 +20,7 @@ provided by gadgets.
 17. UAC2 function
 18. UVC function
 19. PRINTER function
+20. UAC1 function (new API)
 
 
 1. ACM function
@@ -773,3 +774,46 @@ 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.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".
+The uac1 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
index 01c2e2b9ab1dcc66df111012cd043c3e720b37cb..35cc641d9f31bc46fcb91eaa42bc1ca3195b9e0b 100644 (file)
@@ -191,6 +191,9 @@ config USB_F_MASS_STORAGE
 config USB_F_FS
        tristate
 
+config USB_F_UAC1
+       tristate
+
 config USB_F_UAC1_LEGACY
        tristate
 
@@ -365,6 +368,24 @@ config USB_CONFIGFS_F_FS
          implemented in kernel space (for instance Ethernet, serial or
          mass storage) and other are implemented in user space.
 
+config USB_CONFIGFS_F_UAC1
+       bool "Audio Class 1.0"
+       depends on USB_CONFIGFS
+       depends on SND
+       select USB_LIBCOMPOSITE
+       select SND_PCM
+       select USB_U_AUDIO
+       select USB_F_UAC1
+       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_UAC1_LEGACY
        bool "Audio Class 1.0 (legacy implementation)"
        depends on USB_CONFIGFS
@@ -375,8 +396,8 @@ config USB_CONFIGFS_F_UAC1_LEGACY
        help
          This Audio function implements 1 AudioControl interface,
          1 AudioStreaming Interface each for USB-OUT and USB-IN.
-         This driver requires a real Audio codec to be present
-         on the device.
+         This is a legacy driver and requires a real Audio codec
+         to be present on the device.
 
 config USB_CONFIGFS_F_UAC2
        bool "Audio Class 2.0"
index 50ee517faf74449b0baeb59e6f5c9725713b8a67..86e8252699476c1bb7af5d3fa6012eeae2500d7a 100644 (file)
@@ -33,6 +33,8 @@ 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
+obj-$(CONFIG_USB_F_UAC1)       += usb_f_uac1.o
 usb_f_uac1_legacy-y            := f_uac1_legacy.o u_uac1_legacy.o
 obj-$(CONFIG_USB_F_UAC1_LEGACY)        += usb_f_uac1_legacy.o
 usb_f_uac2-y                   := f_uac2.o
diff --git a/drivers/usb/gadget/function/f_uac1.c b/drivers/usb/gadget/function/f_uac1.c
new file mode 100644 (file)
index 0000000..8656f84
--- /dev/null
@@ -0,0 +1,802 @@
+/*
+ * f_uac1.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.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_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_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_opts *to_f_uac1_opts(struct config_item *item)
+{
+       return container_of(to_config_group(item), struct f_uac1_opts,
+                           func_inst.group);
+}
+
+static void f_uac1_attr_release(struct config_item *item)
+{
+       struct f_uac1_opts *opts = to_f_uac1_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_opts_##name##_show(                              \
+                                         struct config_item *item,     \
+                                         char *page)                   \
+{                                                                      \
+       struct f_uac1_opts *opts = to_f_uac1_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_opts_##name##_store(                             \
+                                         struct config_item *item,     \
+                                         const char *page, size_t len) \
+{                                                                      \
+       struct f_uac1_opts *opts = to_f_uac1_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_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_opts_attr_c_chmask,
+       &f_uac1_opts_attr_c_srate,
+       &f_uac1_opts_attr_c_ssize,
+       &f_uac1_opts_attr_p_chmask,
+       &f_uac1_opts_attr_p_srate,
+       &f_uac1_opts_attr_p_ssize,
+       &f_uac1_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_opts *opts;
+
+       opts = container_of(f, struct f_uac1_opts, func_inst);
+       kfree(opts);
+}
+
+static struct usb_function_instance *f_audio_alloc_inst(void)
+{
+       struct f_uac1_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_opts *opts;
+
+       audio = func_to_g_audio(f);
+       opts = container_of(f->fi, struct f_uac1_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_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_opts, func_inst);
+       mutex_lock(&opts->lock);
+       ++opts->refcnt;
+       mutex_unlock(&opts->lock);
+
+       uac1->g_audio.func.name = "uac1_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, f_audio_alloc_inst, f_audio_alloc);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Ruslan Bilovol");
diff --git a/drivers/usb/gadget/function/u_uac1.h b/drivers/usb/gadget/function/u_uac1.h
new file mode 100644 (file)
index 0000000..6f188fd
--- /dev/null
@@ -0,0 +1,41 @@
+/*
+ * u_uac1.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_H
+#define __U_UAC1_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_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_H */
index 87bacb638a9ce83e26f5a1cb55eceba4c430a4dd..a12fb459dbd9f6b8fccb06ce4d5fd18084f0b38b 100644 (file)
@@ -54,9 +54,10 @@ config USB_AUDIO
        depends on SND
        select USB_LIBCOMPOSITE
        select SND_PCM
-       select USB_F_UAC1_LEGACY if GADGET_UAC1_LEGACY
-       select USB_F_UAC2 if !GADGET_UAC1_LEGACY
-       select USB_U_AUDIO if USB_F_UAC2
+       select USB_F_UAC1 if (GADGET_UAC1 && !GADGET_UAC1_LEGACY)
+       select USB_F_UAC1_LEGACY if (GADGET_UAC1 && GADGET_UAC1_LEGACY)
+       select USB_F_UAC2 if !GADGET_UAC1
+       select USB_U_AUDIO if (USB_F_UAC2 || USB_F_UAC1)
        help
          This Gadget Audio driver is compatible with USB Audio Class
          specification 2.0. It implements 1 AudioControl interface,
@@ -73,11 +74,18 @@ config USB_AUDIO
          Say "y" to link the driver statically, or "m" to build a
          dynamically linked module called "g_audio".
 
+config GADGET_UAC1
+       bool "UAC 1.0"
+       depends on USB_AUDIO
+       help
+         If you instead want older USB Audio Class specification 1.0 support
+         with similar driver capabilities.
+
 config GADGET_UAC1_LEGACY
        bool "UAC 1.0 (Legacy)"
-       depends on USB_AUDIO
+       depends on GADGET_UAC1
        help
-         If you instead want older UAC Spec-1.0 driver that also has audio
+         If you instead want legacy UAC Spec-1.0 driver that also has audio
          paths hardwired to the Audio codec chip on-board and doesn't work
          without one.
 
index bf5592a5b9e94b0c1e6044e51e44c472b24ac63b..1f5cdbe162df7d69d2ffc66466905bdb0dedf0ba 100644 (file)
@@ -20,7 +20,7 @@
 
 USB_GADGET_COMPOSITE_OPTIONS();
 
-#ifndef CONFIG_GADGET_UAC1_LEGACY
+#ifndef CONFIG_GADGET_UAC1
 #include "u_uac2.h"
 
 /* Playback(USB-IN) Default Stereo - Fl/Fr */
@@ -53,6 +53,39 @@ static int c_ssize = UAC2_DEF_CSSIZE;
 module_param(c_ssize, uint, S_IRUGO);
 MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)");
 #else
+#ifndef CONFIG_GADGET_UAC1_LEGACY
+#include "u_uac1.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_LEGACY */
 #include "u_uac1_legacy.h"
 
 static char *fn_play = FILE_PCM_PLAYBACK;
@@ -78,6 +111,7 @@ MODULE_PARM_DESC(req_count, "ISO OUT endpoint request count");
 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_LEGACY */
 #endif
 
 /* string IDs are assigned dynamically */
@@ -99,7 +133,7 @@ static struct usb_gadget_strings *audio_strings[] = {
        NULL,
 };
 
-#ifndef CONFIG_GADGET_UAC1_LEGACY
+#ifndef CONFIG_GADGET_UAC1
 static struct usb_function_instance *fi_uac2;
 static struct usb_function *f_uac2;
 #else
@@ -164,7 +198,7 @@ static int audio_do_config(struct usb_configuration *c)
                c->bmAttributes |= USB_CONFIG_ATT_WAKEUP;
        }
 
-#ifdef CONFIG_GADGET_UAC1_LEGACY
+#ifdef CONFIG_GADGET_UAC1
        f_uac1 = usb_get_function(fi_uac1);
        if (IS_ERR(f_uac1)) {
                status = PTR_ERR(f_uac1);
@@ -204,24 +238,32 @@ static struct usb_configuration audio_config_driver = {
 
 static int audio_bind(struct usb_composite_dev *cdev)
 {
-#ifndef CONFIG_GADGET_UAC1_LEGACY
+#ifndef CONFIG_GADGET_UAC1
        struct f_uac2_opts      *uac2_opts;
+#else
+#ifndef CONFIG_GADGET_UAC1_LEGACY
+       struct f_uac1_opts      *uac1_opts;
 #else
        struct f_uac1_legacy_opts       *uac1_opts;
+#endif
 #endif
        int                     status;
 
-#ifndef CONFIG_GADGET_UAC1_LEGACY
+#ifndef CONFIG_GADGET_UAC1
        fi_uac2 = usb_get_function_instance("uac2");
        if (IS_ERR(fi_uac2))
                return PTR_ERR(fi_uac2);
+#else
+#ifndef CONFIG_GADGET_UAC1_LEGACY
+       fi_uac1 = usb_get_function_instance("uac1");
 #else
        fi_uac1 = usb_get_function_instance("uac1_legacy");
+#endif
        if (IS_ERR(fi_uac1))
                return PTR_ERR(fi_uac1);
 #endif
 
-#ifndef CONFIG_GADGET_UAC1_LEGACY
+#ifndef CONFIG_GADGET_UAC1
        uac2_opts = container_of(fi_uac2, struct f_uac2_opts, func_inst);
        uac2_opts->p_chmask = p_chmask;
        uac2_opts->p_srate = p_srate;
@@ -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
+#ifndef CONFIG_GADGET_UAC1_LEGACY
+       uac1_opts = container_of(fi_uac1, struct f_uac1_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_LEGACY */
        uac1_opts = container_of(fi_uac1, struct f_uac1_legacy_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_LEGACY */
 #endif
 
        status = usb_string_ids_tab(cdev, strings_dev);
@@ -269,7 +322,7 @@ fail_otg_desc:
        kfree(otg_desc[0]);
        otg_desc[0] = NULL;
 fail:
-#ifndef CONFIG_GADGET_UAC1_LEGACY
+#ifndef CONFIG_GADGET_UAC1
        usb_put_function_instance(fi_uac2);
 #else
        usb_put_function_instance(fi_uac1);
@@ -279,7 +332,7 @@ fail:
 
 static int audio_unbind(struct usb_composite_dev *cdev)
 {
-#ifdef CONFIG_GADGET_UAC1_LEGACY
+#ifdef CONFIG_GADGET_UAC1
        if (!IS_ERR_OR_NULL(f_uac1))
                usb_put_function(f_uac1);
        if (!IS_ERR_OR_NULL(fi_uac1))