2017-11-03 18:28:30 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2009-06-03 21:17:58 +08:00
|
|
|
/*
|
|
|
|
* f_audio.c -- USB Audio class function driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
|
|
|
|
* Copyright (C) 2008 Analog Devices, Inc
|
|
|
|
*/
|
|
|
|
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2009-06-03 21:17:58 +08:00
|
|
|
#include <linux/kernel.h>
|
2014-07-23 01:58:38 +08:00
|
|
|
#include <linux/module.h>
|
2009-06-03 21:17:58 +08:00
|
|
|
#include <linux/device.h>
|
2011-07-27 07:09:06 +08:00
|
|
|
#include <linux/atomic.h>
|
2009-06-03 21:17:58 +08:00
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
#include "u_uac1_legacy.h"
|
2009-06-03 21:17:58 +08:00
|
|
|
|
2009-06-22 05:21:55 +08:00
|
|
|
static int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value);
|
|
|
|
static int generic_get_cmd(struct usb_audio_control *con, u8 cmd);
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
/*
|
|
|
|
* DESCRIPTORS ... most are static, but strings and full
|
|
|
|
* configuration descriptors are built on demand.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We have two interfaces- AudioControl and AudioStreaming
|
|
|
|
* TODO: only supcard playback currently
|
|
|
|
*/
|
|
|
|
#define F_AUDIO_AC_INTERFACE 0
|
|
|
|
#define F_AUDIO_AS_INTERFACE 1
|
2014-12-10 16:28:15 +08:00
|
|
|
#define F_AUDIO_NUM_INTERFACES 1
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
/* B.3.1 Standard AC Interface Descriptor */
|
2014-07-23 01:58:38 +08:00
|
|
|
static struct usb_interface_descriptor ac_interface_desc = {
|
2009-06-03 21:17:58 +08:00
|
|
|
.bLength = USB_DT_INTERFACE_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_INTERFACE,
|
|
|
|
.bNumEndpoints = 0,
|
|
|
|
.bInterfaceClass = USB_CLASS_AUDIO,
|
|
|
|
.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
|
|
|
|
};
|
|
|
|
|
2014-12-10 16:28:15 +08:00
|
|
|
/*
|
|
|
|
* The number of AudioStreaming and MIDIStreaming interfaces
|
|
|
|
* in the Audio Interface Collection
|
|
|
|
*/
|
|
|
|
DECLARE_UAC_AC_HEADER_DESCRIPTOR(1);
|
2009-06-03 21:17:58 +08:00
|
|
|
|
2009-06-22 05:23:05 +08:00
|
|
|
#define UAC_DT_AC_HEADER_LENGTH UAC_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
|
2009-12-10 11:21:12 +08:00
|
|
|
/* 1 input terminal, 1 output terminal and 1 feature unit */
|
|
|
|
#define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH + UAC_DT_INPUT_TERMINAL_SIZE \
|
|
|
|
+ UAC_DT_OUTPUT_TERMINAL_SIZE + UAC_DT_FEATURE_UNIT_SIZE(0))
|
2009-06-03 21:17:58 +08:00
|
|
|
/* B.3.2 Class-Specific AC Interface Descriptor */
|
2014-12-10 16:28:15 +08:00
|
|
|
static struct uac1_ac_header_descriptor_1 ac_header_desc = {
|
2009-06-22 05:23:05 +08:00
|
|
|
.bLength = UAC_DT_AC_HEADER_LENGTH,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_HEADER,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bcdADC = __constant_cpu_to_le16(0x0100),
|
2009-12-10 11:21:12 +08:00
|
|
|
.wTotalLength = __constant_cpu_to_le16(UAC_DT_TOTAL_LENGTH),
|
2009-06-03 21:17:58 +08:00
|
|
|
.bInCollection = F_AUDIO_NUM_INTERFACES,
|
|
|
|
.baInterfaceNr = {
|
2014-12-10 16:28:15 +08:00
|
|
|
/* Interface number of the first AudioStream interface */
|
|
|
|
[0] = 1,
|
2009-06-03 21:17:58 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
#define INPUT_TERMINAL_ID 1
|
2009-06-22 05:23:05 +08:00
|
|
|
static struct uac_input_terminal_descriptor input_terminal_desc = {
|
|
|
|
.bLength = UAC_DT_INPUT_TERMINAL_SIZE,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_INPUT_TERMINAL,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bTerminalID = INPUT_TERMINAL_ID,
|
2009-06-22 05:23:05 +08:00
|
|
|
.wTerminalType = UAC_TERMINAL_STREAMING,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bAssocTerminal = 0,
|
|
|
|
.wChannelConfig = 0x3,
|
|
|
|
};
|
|
|
|
|
2009-06-22 05:23:05 +08:00
|
|
|
DECLARE_UAC_FEATURE_UNIT_DESCRIPTOR(0);
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
#define FEATURE_UNIT_ID 2
|
2009-06-22 05:23:05 +08:00
|
|
|
static struct uac_feature_unit_descriptor_0 feature_unit_desc = {
|
|
|
|
.bLength = UAC_DT_FEATURE_UNIT_SIZE(0),
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_FEATURE_UNIT,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bUnitID = FEATURE_UNIT_ID,
|
|
|
|
.bSourceID = INPUT_TERMINAL_ID,
|
|
|
|
.bControlSize = 2,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bmaControls[0] = (UAC_FU_MUTE | UAC_FU_VOLUME),
|
2009-06-03 21:17:58 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_audio_control mute_control = {
|
|
|
|
.list = LIST_HEAD_INIT(mute_control.list),
|
|
|
|
.name = "Mute Control",
|
2010-06-01 13:42:03 +08:00
|
|
|
.type = UAC_FU_MUTE,
|
2009-06-03 21:17:58 +08:00
|
|
|
/* Todo: add real Mute control code */
|
|
|
|
.set = generic_set_cmd,
|
|
|
|
.get = generic_get_cmd,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_audio_control volume_control = {
|
|
|
|
.list = LIST_HEAD_INIT(volume_control.list),
|
|
|
|
.name = "Volume Control",
|
2010-06-01 13:42:03 +08:00
|
|
|
.type = UAC_FU_VOLUME,
|
2009-06-03 21:17:58 +08:00
|
|
|
/* Todo: add real Volume control code */
|
|
|
|
.set = generic_set_cmd,
|
|
|
|
.get = generic_get_cmd,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_audio_control_selector feature_unit = {
|
|
|
|
.list = LIST_HEAD_INIT(feature_unit.list),
|
|
|
|
.id = FEATURE_UNIT_ID,
|
|
|
|
.name = "Mute & Volume Control",
|
2009-06-22 05:23:05 +08:00
|
|
|
.type = UAC_FEATURE_UNIT,
|
2009-06-03 21:17:58 +08:00
|
|
|
.desc = (struct usb_descriptor_header *)&feature_unit_desc,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define OUTPUT_TERMINAL_ID 3
|
2010-06-16 23:57:28 +08:00
|
|
|
static struct uac1_output_terminal_descriptor output_terminal_desc = {
|
2009-06-22 05:23:05 +08:00
|
|
|
.bLength = UAC_DT_OUTPUT_TERMINAL_SIZE,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bTerminalID = OUTPUT_TERMINAL_ID,
|
2009-06-22 05:23:05 +08:00
|
|
|
.wTerminalType = UAC_OUTPUT_TERMINAL_SPEAKER,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bAssocTerminal = FEATURE_UNIT_ID,
|
|
|
|
.bSourceID = FEATURE_UNIT_ID,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* B.4.1 Standard AS Interface Descriptor */
|
|
|
|
static struct usb_interface_descriptor as_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_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 */
|
2010-06-16 23:57:28 +08:00
|
|
|
static struct uac1_as_header_descriptor as_header_desc = {
|
2009-06-22 05:23:05 +08:00
|
|
|
.bLength = UAC_DT_AS_HEADER_SIZE,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_AS_GENERAL,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bTerminalLink = INPUT_TERMINAL_ID,
|
|
|
|
.bDelay = 1,
|
2009-06-22 05:23:05 +08:00
|
|
|
.wFormatTag = UAC_FORMAT_TYPE_I_PCM,
|
2009-06-03 21:17:58 +08:00
|
|
|
};
|
|
|
|
|
2009-06-22 05:23:05 +08:00
|
|
|
DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(1);
|
2009-06-03 21:17:58 +08:00
|
|
|
|
2009-06-22 05:23:05 +08:00
|
|
|
static struct uac_format_type_i_discrete_descriptor_1 as_type_i_desc = {
|
|
|
|
.bLength = UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_INTERFACE,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_FORMAT_TYPE,
|
|
|
|
.bFormatType = UAC_FORMAT_TYPE_I,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bSubframeSize = 2,
|
|
|
|
.bBitResolution = 16,
|
|
|
|
.bSamFreqType = 1,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Standard ISO OUT Endpoint Descriptor */
|
2011-05-17 17:02:06 +08:00
|
|
|
static struct usb_endpoint_descriptor as_out_ep_desc = {
|
2009-06-03 21:17:58 +08:00
|
|
|
.bLength = USB_DT_ENDPOINT_AUDIO_SIZE,
|
|
|
|
.bDescriptorType = USB_DT_ENDPOINT,
|
|
|
|
.bEndpointAddress = USB_DIR_OUT,
|
2009-06-22 05:19:23 +08:00
|
|
|
.bmAttributes = USB_ENDPOINT_SYNC_ADAPTIVE
|
2009-06-03 21:17:58 +08:00
|
|
|
| USB_ENDPOINT_XFER_ISOC,
|
2014-07-23 01:58:42 +08:00
|
|
|
.wMaxPacketSize = cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
|
2009-06-03 21:17:58 +08:00
|
|
|
.bInterval = 4,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Class-specific AS ISO OUT Endpoint Descriptor */
|
2014-07-23 01:58:38 +08:00
|
|
|
static struct uac_iso_endpoint_descriptor as_iso_out_desc = {
|
2009-06-22 05:23:05 +08:00
|
|
|
.bLength = UAC_ISO_ENDPOINT_DESC_SIZE,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bDescriptorType = USB_DT_CS_ENDPOINT,
|
2009-06-22 05:23:05 +08:00
|
|
|
.bDescriptorSubtype = UAC_EP_GENERAL,
|
2009-06-03 21:17:58 +08:00
|
|
|
.bmAttributes = 1,
|
|
|
|
.bLockDelayUnits = 1,
|
|
|
|
.wLockDelay = __constant_cpu_to_le16(1),
|
|
|
|
};
|
|
|
|
|
2014-07-23 01:58:38 +08:00
|
|
|
static struct usb_descriptor_header *f_audio_desc[] = {
|
2009-06-03 21:17:58 +08:00
|
|
|
(struct usb_descriptor_header *)&ac_interface_desc,
|
|
|
|
(struct usb_descriptor_header *)&ac_header_desc,
|
|
|
|
|
|
|
|
(struct usb_descriptor_header *)&input_terminal_desc,
|
|
|
|
(struct usb_descriptor_header *)&output_terminal_desc,
|
|
|
|
(struct usb_descriptor_header *)&feature_unit_desc,
|
|
|
|
|
|
|
|
(struct usb_descriptor_header *)&as_interface_alt_0_desc,
|
|
|
|
(struct usb_descriptor_header *)&as_interface_alt_1_desc,
|
|
|
|
(struct usb_descriptor_header *)&as_header_desc,
|
|
|
|
|
|
|
|
(struct usb_descriptor_header *)&as_type_i_desc,
|
|
|
|
|
|
|
|
(struct usb_descriptor_header *)&as_out_ep_desc,
|
|
|
|
(struct usb_descriptor_header *)&as_iso_out_desc,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2014-07-23 01:58:36 +08:00
|
|
|
enum {
|
|
|
|
STR_AC_IF,
|
|
|
|
STR_INPUT_TERMINAL,
|
|
|
|
STR_INPUT_TERMINAL_CH_NAMES,
|
|
|
|
STR_FEAT_DESC_0,
|
|
|
|
STR_OUTPUT_TERMINAL,
|
|
|
|
STR_AS_IF_ALT0,
|
|
|
|
STR_AS_IF_ALT1,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_string strings_uac1[] = {
|
|
|
|
[STR_AC_IF].s = "AC Interface",
|
|
|
|
[STR_INPUT_TERMINAL].s = "Input terminal",
|
|
|
|
[STR_INPUT_TERMINAL_CH_NAMES].s = "Channels",
|
|
|
|
[STR_FEAT_DESC_0].s = "Volume control & mute",
|
|
|
|
[STR_OUTPUT_TERMINAL].s = "Output terminal",
|
|
|
|
[STR_AS_IF_ALT0].s = "AS Interface",
|
|
|
|
[STR_AS_IF_ALT1].s = "AS Interface",
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_gadget_strings str_uac1 = {
|
|
|
|
.language = 0x0409, /* en-us */
|
|
|
|
.strings = strings_uac1,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_gadget_strings *uac1_strings[] = {
|
|
|
|
&str_uac1,
|
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
/*
|
|
|
|
* This function is an ALSA sound card following USB Audio Class Spec 1.0.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
struct f_audio_buf {
|
|
|
|
u8 *buf;
|
|
|
|
int actual;
|
|
|
|
struct list_head list;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct f_audio_buf *f_audio_buffer_alloc(int buf_size)
|
|
|
|
{
|
|
|
|
struct f_audio_buf *copy_buf;
|
|
|
|
|
|
|
|
copy_buf = kzalloc(sizeof *copy_buf, GFP_ATOMIC);
|
|
|
|
if (!copy_buf)
|
2009-12-09 21:23:32 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
copy_buf->buf = kzalloc(buf_size, GFP_ATOMIC);
|
|
|
|
if (!copy_buf->buf) {
|
|
|
|
kfree(copy_buf);
|
2009-12-09 21:23:32 +08:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2009-06-03 21:17:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return copy_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f_audio_buffer_free(struct f_audio_buf *audio_buf)
|
|
|
|
{
|
|
|
|
kfree(audio_buf->buf);
|
|
|
|
kfree(audio_buf);
|
|
|
|
}
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
struct f_audio {
|
|
|
|
struct gaudio card;
|
|
|
|
|
2017-06-18 05:23:58 +08:00
|
|
|
u8 ac_intf, ac_alt;
|
|
|
|
u8 as_intf, as_alt;
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
/* endpoints handle full and/or high speeds */
|
|
|
|
struct usb_ep *out_ep;
|
|
|
|
|
|
|
|
spinlock_t lock;
|
|
|
|
struct f_audio_buf *copy_buf;
|
|
|
|
struct work_struct playback_work;
|
|
|
|
struct list_head play_queue;
|
|
|
|
|
|
|
|
/* Control Set command */
|
|
|
|
struct list_head cs;
|
|
|
|
u8 set_cmd;
|
|
|
|
struct usb_audio_control *set_con;
|
|
|
|
};
|
|
|
|
|
|
|
|
static inline struct f_audio *func_to_audio(struct usb_function *f)
|
|
|
|
{
|
|
|
|
return container_of(f, struct f_audio, card.func);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static void f_audio_playback_work(struct work_struct *data)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = container_of(data, struct f_audio,
|
|
|
|
playback_work);
|
|
|
|
struct f_audio_buf *play_buf;
|
|
|
|
|
|
|
|
spin_lock_irq(&audio->lock);
|
|
|
|
if (list_empty(&audio->play_queue)) {
|
|
|
|
spin_unlock_irq(&audio->lock);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
play_buf = list_first_entry(&audio->play_queue,
|
|
|
|
struct f_audio_buf, list);
|
|
|
|
list_del(&play_buf->list);
|
|
|
|
spin_unlock_irq(&audio->lock);
|
|
|
|
|
|
|
|
u_audio_playback(&audio->card, play_buf->buf, play_buf->actual);
|
|
|
|
f_audio_buffer_free(play_buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int f_audio_out_ep_complete(struct usb_ep *ep, struct usb_request *req)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = req->context;
|
|
|
|
struct usb_composite_dev *cdev = audio->card.func.config->cdev;
|
|
|
|
struct f_audio_buf *copy_buf = audio->copy_buf;
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
int audio_buf_size;
|
2009-06-03 21:17:58 +08:00
|
|
|
int err;
|
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
opts = container_of(audio->card.func.fi, struct f_uac1_legacy_opts,
|
2014-07-23 01:58:38 +08:00
|
|
|
func_inst);
|
|
|
|
audio_buf_size = opts->audio_buf_size;
|
2014-07-23 01:58:40 +08:00
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
if (!copy_buf)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Copy buffer is full, add it to the play_queue */
|
|
|
|
if (audio_buf_size - copy_buf->actual < req->actual) {
|
|
|
|
list_add_tail(©_buf->list, &audio->play_queue);
|
|
|
|
schedule_work(&audio->playback_work);
|
|
|
|
copy_buf = f_audio_buffer_alloc(audio_buf_size);
|
2009-12-09 21:23:32 +08:00
|
|
|
if (IS_ERR(copy_buf))
|
2009-06-03 21:17:58 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(copy_buf->buf + copy_buf->actual, req->buf, req->actual);
|
|
|
|
copy_buf->actual += req->actual;
|
|
|
|
audio->copy_buf = copy_buf;
|
|
|
|
|
|
|
|
err = usb_ep_queue(ep, req, GFP_ATOMIC);
|
|
|
|
if (err)
|
|
|
|
ERROR(cdev, "%s queue req: %d\n", ep->name, err);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f_audio_complete(struct usb_ep *ep, struct usb_request *req)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = req->context;
|
|
|
|
int status = req->status;
|
|
|
|
u32 data = 0;
|
|
|
|
struct usb_ep *out_ep = audio->out_ep;
|
|
|
|
|
|
|
|
switch (status) {
|
|
|
|
|
|
|
|
case 0: /* normal completion? */
|
|
|
|
if (ep == out_ep)
|
|
|
|
f_audio_out_ep_complete(ep, req);
|
|
|
|
else if (audio->set_con) {
|
|
|
|
memcpy(&data, req->buf, req->length);
|
|
|
|
audio->set_con->set(audio->set_con, audio->set_cmd,
|
|
|
|
le16_to_cpu(data));
|
|
|
|
audio->set_con = NULL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int audio_set_intf_req(struct usb_function *f,
|
|
|
|
const struct usb_ctrlrequest *ctrl)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = func_to_audio(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
struct usb_request *req = cdev->req;
|
|
|
|
u8 id = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
|
|
|
|
u16 len = le16_to_cpu(ctrl->wLength);
|
|
|
|
u16 w_value = le16_to_cpu(ctrl->wValue);
|
|
|
|
u8 con_sel = (w_value >> 8) & 0xFF;
|
|
|
|
u8 cmd = (ctrl->bRequest & 0x0F);
|
|
|
|
struct usb_audio_control_selector *cs;
|
|
|
|
struct usb_audio_control *con;
|
|
|
|
|
|
|
|
DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, entity %d\n",
|
|
|
|
ctrl->bRequest, w_value, len, id);
|
|
|
|
|
|
|
|
list_for_each_entry(cs, &audio->cs, list) {
|
|
|
|
if (cs->id == id) {
|
|
|
|
list_for_each_entry(con, &cs->control, list) {
|
|
|
|
if (con->type == con_sel) {
|
|
|
|
audio->set_con = con;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
audio->set_cmd = cmd;
|
|
|
|
req->context = audio;
|
|
|
|
req->complete = f_audio_complete;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int audio_get_intf_req(struct usb_function *f,
|
|
|
|
const struct usb_ctrlrequest *ctrl)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = func_to_audio(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
struct usb_request *req = cdev->req;
|
|
|
|
int value = -EOPNOTSUPP;
|
|
|
|
u8 id = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
|
|
|
|
u16 len = le16_to_cpu(ctrl->wLength);
|
|
|
|
u16 w_value = le16_to_cpu(ctrl->wValue);
|
|
|
|
u8 con_sel = (w_value >> 8) & 0xFF;
|
|
|
|
u8 cmd = (ctrl->bRequest & 0x0F);
|
|
|
|
struct usb_audio_control_selector *cs;
|
|
|
|
struct usb_audio_control *con;
|
|
|
|
|
|
|
|
DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, entity %d\n",
|
|
|
|
ctrl->bRequest, w_value, len, id);
|
|
|
|
|
|
|
|
list_for_each_entry(cs, &audio->cs, list) {
|
|
|
|
if (cs->id == id) {
|
|
|
|
list_for_each_entry(con, &cs->control, list) {
|
|
|
|
if (con->type == con_sel && con->get) {
|
|
|
|
value = con->get(con, cmd);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
req->context = audio;
|
|
|
|
req->complete = f_audio_complete;
|
2013-02-28 12:43:12 +08:00
|
|
|
len = min_t(size_t, sizeof(value), len);
|
2009-06-03 21:17:58 +08:00
|
|
|
memcpy(req->buf, &value, len);
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2009-10-21 06:03:39 +08:00
|
|
|
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:
|
2011-08-29 16:54:08 +08:00
|
|
|
value = len;
|
2009-10-21 06:03:39 +08:00
|
|
|
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:
|
2011-08-29 16:54:08 +08:00
|
|
|
value = len;
|
2009-10-21 06:03:39 +08:00
|
|
|
break;
|
|
|
|
case UAC_GET_MEM:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
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);
|
|
|
|
|
2009-10-21 06:03:39 +08:00
|
|
|
/* composite driver infrastructure handles everything; interface
|
|
|
|
* activation uses set_alt().
|
2009-06-03 21:17:58 +08:00
|
|
|
*/
|
|
|
|
switch (ctrl->bRequestType) {
|
2009-06-22 05:23:05 +08:00
|
|
|
case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
|
2009-06-03 21:17:58 +08:00
|
|
|
value = audio_set_intf_req(f, ctrl);
|
|
|
|
break;
|
|
|
|
|
2009-06-22 05:23:05 +08:00
|
|
|
case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
|
2009-06-03 21:17:58 +08:00
|
|
|
value = audio_get_intf_req(f, ctrl);
|
|
|
|
break;
|
|
|
|
|
2009-10-21 06:03:39 +08:00
|
|
|
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;
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
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 f_audio *audio = func_to_audio(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
struct usb_ep *out_ep = audio->out_ep;
|
|
|
|
struct usb_request *req;
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
int req_buf_size, req_count, audio_buf_size;
|
2009-06-03 21:17:58 +08:00
|
|
|
int i = 0, err = 0;
|
|
|
|
|
|
|
|
DBG(cdev, "intf %d, alt %d\n", intf, alt);
|
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
opts = container_of(f->fi, struct f_uac1_legacy_opts, func_inst);
|
2014-07-23 01:58:38 +08:00
|
|
|
req_buf_size = opts->req_buf_size;
|
|
|
|
req_count = opts->req_count;
|
|
|
|
audio_buf_size = opts->audio_buf_size;
|
|
|
|
|
2017-06-18 05:23:58 +08:00
|
|
|
/* No i/f has more than 2 alt settings */
|
|
|
|
if (alt > 1) {
|
|
|
|
ERROR(cdev, "%s:%d Error!\n", __func__, __LINE__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (intf == audio->ac_intf) {
|
|
|
|
/* Control I/f has only 1 AltSetting - 0 */
|
|
|
|
if (alt) {
|
|
|
|
ERROR(cdev, "%s:%d Error!\n", __func__, __LINE__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
} else if (intf == audio->as_intf) {
|
2009-06-03 21:17:58 +08:00
|
|
|
if (alt == 1) {
|
2015-05-18 23:28:58 +08:00
|
|
|
err = config_ep_by_speed(cdev->gadget, f, out_ep);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2011-06-28 21:33:48 +08:00
|
|
|
usb_ep_enable(out_ep);
|
2009-06-03 21:17:58 +08:00
|
|
|
audio->copy_buf = f_audio_buffer_alloc(audio_buf_size);
|
2009-12-09 21:23:32 +08:00
|
|
|
if (IS_ERR(audio->copy_buf))
|
|
|
|
return -ENOMEM;
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate a bunch of read buffers
|
|
|
|
* and queue them all at once.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < req_count && err == 0; i++) {
|
|
|
|
req = usb_ep_alloc_request(out_ep, GFP_ATOMIC);
|
|
|
|
if (req) {
|
|
|
|
req->buf = kzalloc(req_buf_size,
|
|
|
|
GFP_ATOMIC);
|
|
|
|
if (req->buf) {
|
|
|
|
req->length = req_buf_size;
|
|
|
|
req->context = audio;
|
|
|
|
req->complete =
|
|
|
|
f_audio_complete;
|
|
|
|
err = usb_ep_queue(out_ep,
|
|
|
|
req, GFP_ATOMIC);
|
|
|
|
if (err)
|
|
|
|
ERROR(cdev,
|
|
|
|
"%s queue req: %d\n",
|
|
|
|
out_ep->name, err);
|
|
|
|
} else
|
|
|
|
err = -ENOMEM;
|
|
|
|
} else
|
|
|
|
err = -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else {
|
|
|
|
struct f_audio_buf *copy_buf = audio->copy_buf;
|
|
|
|
if (copy_buf) {
|
|
|
|
list_add_tail(©_buf->list,
|
|
|
|
&audio->play_queue);
|
|
|
|
schedule_work(&audio->playback_work);
|
|
|
|
}
|
|
|
|
}
|
2017-06-18 05:23:58 +08:00
|
|
|
audio->as_alt = alt;
|
2009-06-03 21:17:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-06-18 05:23:58 +08:00
|
|
|
static int f_audio_get_alt(struct usb_function *f, unsigned intf)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = func_to_audio(f);
|
|
|
|
struct usb_composite_dev *cdev = f->config->cdev;
|
|
|
|
|
|
|
|
if (intf == audio->ac_intf)
|
|
|
|
return audio->ac_alt;
|
|
|
|
else if (intf == audio->as_intf)
|
|
|
|
return audio->as_alt;
|
|
|
|
else
|
|
|
|
ERROR(cdev, "%s:%d Invalid Interface %d!\n",
|
|
|
|
__func__, __LINE__, intf);
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
static void f_audio_disable(struct usb_function *f)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
static void f_audio_build_desc(struct f_audio *audio)
|
|
|
|
{
|
|
|
|
struct gaudio *card = &audio->card;
|
|
|
|
u8 *sam_freq;
|
|
|
|
int rate;
|
|
|
|
|
|
|
|
/* Set channel numbers */
|
|
|
|
input_terminal_desc.bNrChannels = u_audio_get_playback_channels(card);
|
|
|
|
as_type_i_desc.bNrChannels = u_audio_get_playback_channels(card);
|
|
|
|
|
|
|
|
/* Set sample rates */
|
|
|
|
rate = u_audio_get_playback_rate(card);
|
|
|
|
sam_freq = as_type_i_desc.tSamFreq[0];
|
|
|
|
memcpy(sam_freq, &rate, 3);
|
|
|
|
|
|
|
|
/* Todo: Set Sample bits and other parameters */
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* audio function driver setup/binding */
|
2014-07-23 01:58:38 +08:00
|
|
|
static int
|
2009-06-03 21:17:58 +08:00
|
|
|
f_audio_bind(struct usb_configuration *c, struct usb_function *f)
|
|
|
|
{
|
|
|
|
struct usb_composite_dev *cdev = c->cdev;
|
|
|
|
struct f_audio *audio = func_to_audio(f);
|
2014-07-23 01:58:41 +08:00
|
|
|
struct usb_string *us;
|
2009-06-03 21:17:58 +08:00
|
|
|
int status;
|
2012-10-23 04:15:06 +08:00
|
|
|
struct usb_ep *ep = NULL;
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *audio_opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
audio_opts = container_of(f->fi, struct f_uac1_legacy_opts, func_inst);
|
2014-07-23 01:58:38 +08:00
|
|
|
audio->card.gadget = c->cdev->gadget;
|
|
|
|
/* set up ASLA audio devices */
|
|
|
|
if (!audio_opts->bound) {
|
|
|
|
status = gaudio_setup(&audio->card);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
audio_opts->bound = true;
|
|
|
|
}
|
2014-07-23 01:58:41 +08:00
|
|
|
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;
|
|
|
|
input_terminal_desc.iTerminal = us[STR_INPUT_TERMINAL].id;
|
|
|
|
input_terminal_desc.iChannelNames = us[STR_INPUT_TERMINAL_CH_NAMES].id;
|
|
|
|
feature_unit_desc.iFeature = us[STR_FEAT_DESC_0].id;
|
|
|
|
output_terminal_desc.iTerminal = us[STR_OUTPUT_TERMINAL].id;
|
|
|
|
as_interface_alt_0_desc.iInterface = us[STR_AS_IF_ALT0].id;
|
|
|
|
as_interface_alt_1_desc.iInterface = us[STR_AS_IF_ALT1].id;
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
f_audio_build_desc(audio);
|
|
|
|
|
|
|
|
/* allocate instance-specific interface IDs, and patch descriptors */
|
|
|
|
status = usb_interface_id(c, f);
|
|
|
|
if (status < 0)
|
|
|
|
goto fail;
|
|
|
|
ac_interface_desc.bInterfaceNumber = status;
|
2017-06-18 05:23:58 +08:00
|
|
|
audio->ac_intf = status;
|
|
|
|
audio->ac_alt = 0;
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
status = usb_interface_id(c, f);
|
|
|
|
if (status < 0)
|
|
|
|
goto fail;
|
|
|
|
as_interface_alt_0_desc.bInterfaceNumber = status;
|
|
|
|
as_interface_alt_1_desc.bInterfaceNumber = status;
|
2017-06-18 05:23:58 +08:00
|
|
|
audio->as_intf = status;
|
|
|
|
audio->as_alt = 0;
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
status = -ENODEV;
|
|
|
|
|
|
|
|
/* allocate instance-specific endpoints */
|
|
|
|
ep = usb_ep_autoconfig(cdev->gadget, &as_out_ep_desc);
|
|
|
|
if (!ep)
|
|
|
|
goto fail;
|
|
|
|
audio->out_ep = ep;
|
2011-06-28 21:33:48 +08:00
|
|
|
audio->out_ep->desc = &as_out_ep_desc;
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
status = -ENOMEM;
|
|
|
|
|
2011-08-26 17:48:15 +08:00
|
|
|
/* copy descriptors, and track endpoint copies */
|
2016-02-06 09:06:07 +08:00
|
|
|
status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, NULL,
|
|
|
|
NULL);
|
2012-10-23 04:15:06 +08:00
|
|
|
if (status)
|
|
|
|
goto fail;
|
2009-06-03 21:17:58 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
2014-07-23 01:58:38 +08:00
|
|
|
gaudio_cleanup(&audio->card);
|
2009-06-03 21:17:58 +08:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------*/
|
|
|
|
|
2009-06-22 05:21:55 +08:00
|
|
|
static int generic_set_cmd(struct usb_audio_control *con, u8 cmd, int value)
|
|
|
|
{
|
|
|
|
con->data[cmd] = value;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int generic_get_cmd(struct usb_audio_control *con, u8 cmd)
|
|
|
|
{
|
|
|
|
return con->data[cmd];
|
|
|
|
}
|
|
|
|
|
2009-06-03 21:17:58 +08:00
|
|
|
/* Todo: add more control selecotor dynamically */
|
2014-07-23 01:58:38 +08:00
|
|
|
static int control_selector_init(struct f_audio *audio)
|
2009-06-03 21:17:58 +08:00
|
|
|
{
|
|
|
|
INIT_LIST_HEAD(&audio->cs);
|
|
|
|
list_add(&feature_unit.list, &audio->cs);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&feature_unit.control);
|
|
|
|
list_add(&mute_control.list, &feature_unit.control);
|
|
|
|
list_add(&volume_control.list, &feature_unit.control);
|
|
|
|
|
2009-06-22 05:23:05 +08:00
|
|
|
volume_control.data[UAC__CUR] = 0xffc0;
|
|
|
|
volume_control.data[UAC__MIN] = 0xe3a0;
|
|
|
|
volume_control.data[UAC__MAX] = 0xfff0;
|
|
|
|
volume_control.data[UAC__RES] = 0x0030;
|
2009-06-03 21:17:58 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
static inline
|
|
|
|
struct f_uac1_legacy_opts *to_f_uac1_opts(struct config_item *item)
|
2014-07-23 01:58:43 +08:00
|
|
|
{
|
2017-06-18 21:23:53 +08:00
|
|
|
return container_of(to_config_group(item), struct f_uac1_legacy_opts,
|
2014-07-23 01:58:43 +08:00
|
|
|
func_inst.group);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f_uac1_attr_release(struct config_item *item)
|
|
|
|
{
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts = to_f_uac1_opts(item);
|
2014-07-23 01:58:43 +08:00
|
|
|
|
|
|
|
usb_put_function_instance(&opts->func_inst);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct configfs_item_operations f_uac1_item_ops = {
|
|
|
|
.release = f_uac1_attr_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
#define UAC1_INT_ATTRIBUTE(name) \
|
2015-10-03 21:32:48 +08:00
|
|
|
static ssize_t f_uac1_opts_##name##_show(struct config_item *item, \
|
2014-07-23 01:58:43 +08:00
|
|
|
char *page) \
|
|
|
|
{ \
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts = to_f_uac1_opts(item); \
|
2014-07-23 01:58:43 +08:00
|
|
|
int result; \
|
|
|
|
\
|
|
|
|
mutex_lock(&opts->lock); \
|
|
|
|
result = sprintf(page, "%u\n", opts->name); \
|
|
|
|
mutex_unlock(&opts->lock); \
|
|
|
|
\
|
|
|
|
return result; \
|
|
|
|
} \
|
|
|
|
\
|
2015-10-03 21:32:48 +08:00
|
|
|
static ssize_t f_uac1_opts_##name##_store(struct config_item *item, \
|
2014-07-23 01:58:43 +08:00
|
|
|
const char *page, size_t len) \
|
|
|
|
{ \
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts = to_f_uac1_opts(item); \
|
2014-07-23 01:58:43 +08:00
|
|
|
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; \
|
|
|
|
} \
|
|
|
|
\
|
2015-10-03 21:32:48 +08:00
|
|
|
CONFIGFS_ATTR(f_uac1_opts_, name)
|
2014-07-23 01:58:43 +08:00
|
|
|
|
|
|
|
UAC1_INT_ATTRIBUTE(req_buf_size);
|
|
|
|
UAC1_INT_ATTRIBUTE(req_count);
|
|
|
|
UAC1_INT_ATTRIBUTE(audio_buf_size);
|
|
|
|
|
|
|
|
#define UAC1_STR_ATTRIBUTE(name) \
|
2015-10-03 21:32:48 +08:00
|
|
|
static ssize_t f_uac1_opts_##name##_show(struct config_item *item, \
|
2014-07-23 01:58:43 +08:00
|
|
|
char *page) \
|
|
|
|
{ \
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts = to_f_uac1_opts(item); \
|
2014-07-23 01:58:43 +08:00
|
|
|
int result; \
|
|
|
|
\
|
|
|
|
mutex_lock(&opts->lock); \
|
|
|
|
result = sprintf(page, "%s\n", opts->name); \
|
|
|
|
mutex_unlock(&opts->lock); \
|
|
|
|
\
|
|
|
|
return result; \
|
|
|
|
} \
|
|
|
|
\
|
2015-10-03 21:32:48 +08:00
|
|
|
static ssize_t f_uac1_opts_##name##_store(struct config_item *item, \
|
2014-07-23 01:58:43 +08:00
|
|
|
const char *page, size_t len) \
|
|
|
|
{ \
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts = to_f_uac1_opts(item); \
|
2014-07-23 01:58:43 +08:00
|
|
|
int ret = -EBUSY; \
|
|
|
|
char *tmp; \
|
|
|
|
\
|
|
|
|
mutex_lock(&opts->lock); \
|
|
|
|
if (opts->refcnt) \
|
|
|
|
goto end; \
|
|
|
|
\
|
|
|
|
tmp = kstrndup(page, len, GFP_KERNEL); \
|
|
|
|
if (tmp) { \
|
|
|
|
ret = -ENOMEM; \
|
|
|
|
goto end; \
|
|
|
|
} \
|
|
|
|
if (opts->name##_alloc) \
|
|
|
|
kfree(opts->name); \
|
|
|
|
opts->name##_alloc = true; \
|
|
|
|
opts->name = tmp; \
|
|
|
|
ret = len; \
|
|
|
|
\
|
|
|
|
end: \
|
|
|
|
mutex_unlock(&opts->lock); \
|
|
|
|
return ret; \
|
|
|
|
} \
|
|
|
|
\
|
2015-10-03 21:32:48 +08:00
|
|
|
CONFIGFS_ATTR(f_uac1_opts_, name)
|
2014-07-23 01:58:43 +08:00
|
|
|
|
|
|
|
UAC1_STR_ATTRIBUTE(fn_play);
|
|
|
|
UAC1_STR_ATTRIBUTE(fn_cap);
|
|
|
|
UAC1_STR_ATTRIBUTE(fn_cntl);
|
|
|
|
|
|
|
|
static struct configfs_attribute *f_uac1_attrs[] = {
|
2015-10-03 21:32:48 +08:00
|
|
|
&f_uac1_opts_attr_req_buf_size,
|
|
|
|
&f_uac1_opts_attr_req_count,
|
|
|
|
&f_uac1_opts_attr_audio_buf_size,
|
|
|
|
&f_uac1_opts_attr_fn_play,
|
|
|
|
&f_uac1_opts_attr_fn_cap,
|
|
|
|
&f_uac1_opts_attr_fn_cntl,
|
2014-07-23 01:58:43 +08:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2017-10-16 23:18:41 +08:00
|
|
|
static const struct config_item_type f_uac1_func_type = {
|
2014-07-23 01:58:43 +08:00
|
|
|
.ct_item_ops = &f_uac1_item_ops,
|
|
|
|
.ct_attrs = f_uac1_attrs,
|
|
|
|
.ct_owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2014-07-23 01:58:38 +08:00
|
|
|
static void f_audio_free_inst(struct usb_function_instance *f)
|
|
|
|
{
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
opts = container_of(f, struct f_uac1_legacy_opts, func_inst);
|
2014-07-23 01:58:43 +08:00
|
|
|
if (opts->fn_play_alloc)
|
|
|
|
kfree(opts->fn_play);
|
|
|
|
if (opts->fn_cap_alloc)
|
|
|
|
kfree(opts->fn_cap);
|
|
|
|
if (opts->fn_cntl_alloc)
|
|
|
|
kfree(opts->fn_cntl);
|
2014-07-23 01:58:38 +08:00
|
|
|
kfree(opts);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_function_instance *f_audio_alloc_inst(void)
|
|
|
|
{
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
|
|
|
|
opts = kzalloc(sizeof(*opts), GFP_KERNEL);
|
|
|
|
if (!opts)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
2014-07-23 01:58:43 +08:00
|
|
|
mutex_init(&opts->lock);
|
2014-07-23 01:58:38 +08:00
|
|
|
opts->func_inst.free_func_inst = f_audio_free_inst;
|
|
|
|
|
2014-07-23 01:58:43 +08:00
|
|
|
config_group_init_type_name(&opts->func_inst.group, "",
|
|
|
|
&f_uac1_func_type);
|
|
|
|
|
|
|
|
opts->req_buf_size = UAC1_OUT_EP_MAX_PACKET_SIZE;
|
|
|
|
opts->req_count = UAC1_REQ_COUNT;
|
|
|
|
opts->audio_buf_size = UAC1_AUDIO_BUF_SIZE;
|
|
|
|
opts->fn_play = FILE_PCM_PLAYBACK;
|
|
|
|
opts->fn_cap = FILE_PCM_CAPTURE;
|
|
|
|
opts->fn_cntl = FILE_CONTROL;
|
2014-07-23 01:58:38 +08:00
|
|
|
return &opts->func_inst;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void f_audio_free(struct usb_function *f)
|
|
|
|
{
|
|
|
|
struct f_audio *audio = func_to_audio(f);
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
|
2014-12-01 16:09:27 +08:00
|
|
|
gaudio_cleanup(&audio->card);
|
2017-06-18 21:23:53 +08:00
|
|
|
opts = container_of(f->fi, struct f_uac1_legacy_opts, func_inst);
|
2014-07-23 01:58:38 +08:00
|
|
|
kfree(audio);
|
2014-07-23 01:58:43 +08:00
|
|
|
mutex_lock(&opts->lock);
|
|
|
|
--opts->refcnt;
|
|
|
|
mutex_unlock(&opts->lock);
|
2014-07-23 01:58:38 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
|
|
|
|
{
|
|
|
|
usb_free_all_descriptors(f);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
|
|
|
|
{
|
|
|
|
struct f_audio *audio;
|
2017-06-18 21:23:53 +08:00
|
|
|
struct f_uac1_legacy_opts *opts;
|
2014-07-23 01:58:38 +08:00
|
|
|
|
|
|
|
/* allocate and initialize one new instance */
|
|
|
|
audio = kzalloc(sizeof(*audio), GFP_KERNEL);
|
|
|
|
if (!audio)
|
|
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
|
|
|
|
audio->card.func.name = "g_audio";
|
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
opts = container_of(fi, struct f_uac1_legacy_opts, func_inst);
|
2014-07-23 01:58:43 +08:00
|
|
|
mutex_lock(&opts->lock);
|
|
|
|
++opts->refcnt;
|
|
|
|
mutex_unlock(&opts->lock);
|
2014-07-23 01:58:38 +08:00
|
|
|
INIT_LIST_HEAD(&audio->play_queue);
|
|
|
|
spin_lock_init(&audio->lock);
|
|
|
|
|
|
|
|
audio->card.func.bind = f_audio_bind;
|
|
|
|
audio->card.func.unbind = f_audio_unbind;
|
|
|
|
audio->card.func.set_alt = f_audio_set_alt;
|
2017-06-18 05:23:58 +08:00
|
|
|
audio->card.func.get_alt = f_audio_get_alt;
|
2014-07-23 01:58:38 +08:00
|
|
|
audio->card.func.setup = f_audio_setup;
|
|
|
|
audio->card.func.disable = f_audio_disable;
|
|
|
|
audio->card.func.free_func = f_audio_free;
|
|
|
|
|
|
|
|
control_selector_init(audio);
|
|
|
|
|
|
|
|
INIT_WORK(&audio->playback_work, f_audio_playback_work);
|
|
|
|
|
|
|
|
return &audio->card.func;
|
|
|
|
}
|
|
|
|
|
2017-06-18 21:23:53 +08:00
|
|
|
DECLARE_USB_FUNCTION_INIT(uac1_legacy, f_audio_alloc_inst, f_audio_alloc);
|
2014-07-23 01:58:38 +08:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_AUTHOR("Bryan Wu");
|