1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * f_uac1.c -- USB Audio Class 1.0 Function (using u_audio API)
   4 *
   5 * Copyright (C) 2016 Ruslan Bilovol <ruslan.bilovol@gmail.com>
   6 * Copyright (C) 2021 Julian Scheel <julian@jusst.de>
   7 *
   8 * This driver doesn't expect any real Audio codec to be present
   9 * on the device - the audio streams are simply sinked to and
  10 * sourced from a virtual ALSA sound card created.
  11 *
  12 * This file is based on f_uac1.c which is
  13 *   Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
  14 *   Copyright (C) 2008 Analog Devices, Inc
  15 */
  16
  17#include <linux/usb/audio.h>
  18#include <linux/module.h>
  19
  20#include "u_audio.h"
  21#include "u_uac1.h"
  22
  23/* UAC1 spec: 3.7.2.3 Audio Channel Cluster Format */
  24#define UAC1_CHANNEL_MASK 0x0FFF
  25
  26#define USB_OUT_FU_ID	(out_feature_unit_desc->bUnitID)
  27#define USB_IN_FU_ID	(in_feature_unit_desc->bUnitID)
  28
  29#define EPIN_EN(_opts) ((_opts)->p_chmask != 0)
  30#define EPOUT_EN(_opts) ((_opts)->c_chmask != 0)
  31#define FUIN_EN(_opts) ((_opts)->p_mute_present \
  32			|| (_opts)->p_volume_present)
  33#define FUOUT_EN(_opts) ((_opts)->c_mute_present \
  34			|| (_opts)->c_volume_present)
  35
  36struct f_uac1 {
  37	struct g_audio g_audio;
  38	u8 ac_intf, as_in_intf, as_out_intf;
  39	u8 ac_alt, as_in_alt, as_out_alt;	/* needed for get_alt() */
  40
  41	struct usb_ctrlrequest setup_cr;	/* will be used in data stage */
  42
  43	/* Interrupt IN endpoint of AC interface */
  44	struct usb_ep	*int_ep;
  45	atomic_t	int_count;
  46	int ctl_id;		/* EP id */
  47	int c_srate;	/* current capture srate */
  48	int p_srate;	/* current playback prate */
  49};
  50
  51static inline struct f_uac1 *func_to_uac1(struct usb_function *f)
  52{
  53	return container_of(f, struct f_uac1, g_audio.func);
  54}
  55
  56static inline struct f_uac1_opts *g_audio_to_uac1_opts(struct g_audio *audio)
  57{
  58	return container_of(audio->func.fi, struct f_uac1_opts, func_inst);
  59}
  60
  61/*
  62 * DESCRIPTORS ... most are static, but strings and full
  63 * configuration descriptors are built on demand.
  64 */
  65
  66/*
  67 * We have three interfaces - one AudioControl and two AudioStreaming
  68 *
  69 * The driver implements a simple UAC_1 topology.
  70 * USB-OUT -> IT_1 -> OT_2 -> ALSA_Capture
  71 * ALSA_Playback -> IT_3 -> OT_4 -> USB-IN
  72 */
  73
  74/* B.3.1  Standard AC Interface Descriptor */
  75static struct usb_interface_descriptor ac_interface_desc = {
  76	.bLength =		USB_DT_INTERFACE_SIZE,
  77	.bDescriptorType =	USB_DT_INTERFACE,
  78	/* .bNumEndpoints =	DYNAMIC */
  79	.bInterfaceClass =	USB_CLASS_AUDIO,
  80	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOCONTROL,
  81};
  82
  83/* B.3.2  Class-Specific AC Interface Descriptor */
  84static struct uac1_ac_header_descriptor *ac_header_desc;
  85
  86static struct uac_input_terminal_descriptor usb_out_it_desc = {
  87	.bLength =		UAC_DT_INPUT_TERMINAL_SIZE,
  88	.bDescriptorType =	USB_DT_CS_INTERFACE,
  89	.bDescriptorSubtype =	UAC_INPUT_TERMINAL,
  90	/* .bTerminalID =	DYNAMIC */
  91	.wTerminalType =	cpu_to_le16(UAC_TERMINAL_STREAMING),
  92	.bAssocTerminal =	0,
  93	.wChannelConfig =	cpu_to_le16(0x3),
  94};
  95
  96static struct uac1_output_terminal_descriptor io_out_ot_desc = {
  97	.bLength		= UAC_DT_OUTPUT_TERMINAL_SIZE,
  98	.bDescriptorType	= USB_DT_CS_INTERFACE,
  99	.bDescriptorSubtype	= UAC_OUTPUT_TERMINAL,
 100	/* .bTerminalID =	DYNAMIC */
 101	.wTerminalType		= cpu_to_le16(UAC_OUTPUT_TERMINAL_SPEAKER),
 102	.bAssocTerminal		= 0,
 103	/* .bSourceID =		DYNAMIC */
 104};
 105
 106static struct uac_input_terminal_descriptor io_in_it_desc = {
 107	.bLength		= UAC_DT_INPUT_TERMINAL_SIZE,
 108	.bDescriptorType	= USB_DT_CS_INTERFACE,
 109	.bDescriptorSubtype	= UAC_INPUT_TERMINAL,
 110	/* .bTerminalID		= DYNAMIC */
 111	.wTerminalType		= cpu_to_le16(UAC_INPUT_TERMINAL_MICROPHONE),
 112	.bAssocTerminal		= 0,
 113	.wChannelConfig		= cpu_to_le16(0x3),
 114};
 115
 116static struct uac1_output_terminal_descriptor usb_in_ot_desc = {
 117	.bLength =		UAC_DT_OUTPUT_TERMINAL_SIZE,
 118	.bDescriptorType =	USB_DT_CS_INTERFACE,
 119	.bDescriptorSubtype =	UAC_OUTPUT_TERMINAL,
 120	/* .bTerminalID =	DYNAMIC */
 121	.wTerminalType =	cpu_to_le16(UAC_TERMINAL_STREAMING),
 122	.bAssocTerminal =	0,
 123	/* .bSourceID =		DYNAMIC */
 124};
 125
 126static struct uac_feature_unit_descriptor *in_feature_unit_desc;
 127static struct uac_feature_unit_descriptor *out_feature_unit_desc;
 128
 129/* AC IN Interrupt Endpoint */
 130static struct usb_endpoint_descriptor ac_int_ep_desc = {
 131	.bLength = USB_DT_ENDPOINT_SIZE,
 132	.bDescriptorType = USB_DT_ENDPOINT,
 133	.bEndpointAddress = USB_DIR_IN,
 134	.bmAttributes = USB_ENDPOINT_XFER_INT,
 135	.wMaxPacketSize = cpu_to_le16(2),
 136	.bInterval = 4,
 137};
 138
 139/* B.4.1  Standard AS Interface Descriptor */
 140static struct usb_interface_descriptor as_out_interface_alt_0_desc = {
 141	.bLength =		USB_DT_INTERFACE_SIZE,
 142	.bDescriptorType =	USB_DT_INTERFACE,
 143	.bAlternateSetting =	0,
 144	.bNumEndpoints =	0,
 145	.bInterfaceClass =	USB_CLASS_AUDIO,
 146	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
 147};
 148
 149static struct usb_interface_descriptor as_out_interface_alt_1_desc = {
 150	.bLength =		USB_DT_INTERFACE_SIZE,
 151	.bDescriptorType =	USB_DT_INTERFACE,
 152	.bAlternateSetting =	1,
 153	.bNumEndpoints =	1,
 154	.bInterfaceClass =	USB_CLASS_AUDIO,
 155	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
 156};
 157
 158static struct usb_interface_descriptor as_in_interface_alt_0_desc = {
 159	.bLength =		USB_DT_INTERFACE_SIZE,
 160	.bDescriptorType =	USB_DT_INTERFACE,
 161	.bAlternateSetting =	0,
 162	.bNumEndpoints =	0,
 163	.bInterfaceClass =	USB_CLASS_AUDIO,
 164	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
 165};
 166
 167static struct usb_interface_descriptor as_in_interface_alt_1_desc = {
 168	.bLength =		USB_DT_INTERFACE_SIZE,
 169	.bDescriptorType =	USB_DT_INTERFACE,
 170	.bAlternateSetting =	1,
 171	.bNumEndpoints =	1,
 172	.bInterfaceClass =	USB_CLASS_AUDIO,
 173	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
 174};
 175
 176/* B.4.2  Class-Specific AS Interface Descriptor */
 177static struct uac1_as_header_descriptor as_out_header_desc = {
 178	.bLength =		UAC_DT_AS_HEADER_SIZE,
 179	.bDescriptorType =	USB_DT_CS_INTERFACE,
 180	.bDescriptorSubtype =	UAC_AS_GENERAL,
 181	/* .bTerminalLink =	DYNAMIC */
 182	.bDelay =		1,
 183	.wFormatTag =		cpu_to_le16(UAC_FORMAT_TYPE_I_PCM),
 184};
 185
 186static struct uac1_as_header_descriptor as_in_header_desc = {
 187	.bLength =		UAC_DT_AS_HEADER_SIZE,
 188	.bDescriptorType =	USB_DT_CS_INTERFACE,
 189	.bDescriptorSubtype =	UAC_AS_GENERAL,
 190	/* .bTerminalLink =	DYNAMIC */
 191	.bDelay =		1,
 192	.wFormatTag =		cpu_to_le16(UAC_FORMAT_TYPE_I_PCM),
 193};
 194
 195DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(UAC_MAX_RATES);
 196#define uac_format_type_i_discrete_descriptor			\
 197	uac_format_type_i_discrete_descriptor_##UAC_MAX_RATES
 198
 199static struct uac_format_type_i_discrete_descriptor as_out_type_i_desc = {
 200	.bLength =		0, /* filled on rate setup */
 201	.bDescriptorType =	USB_DT_CS_INTERFACE,
 202	.bDescriptorSubtype =	UAC_FORMAT_TYPE,
 203	.bFormatType =		UAC_FORMAT_TYPE_I,
 204	.bSubframeSize =	2,
 205	.bBitResolution =	16,
 206	.bSamFreqType =		0, /* filled on rate setup */
 207};
 208
 209/* Standard ISO OUT Endpoint Descriptor */
 210static struct usb_endpoint_descriptor as_out_ep_desc  = {
 211	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
 212	.bDescriptorType =	USB_DT_ENDPOINT,
 213	.bEndpointAddress =	USB_DIR_OUT,
 214	.bmAttributes =		USB_ENDPOINT_SYNC_ADAPTIVE
 215				| USB_ENDPOINT_XFER_ISOC,
 216	.wMaxPacketSize	=	cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
 217	.bInterval =		4,
 218};
 219
 220/* Class-specific AS ISO OUT Endpoint Descriptor */
 221static struct uac_iso_endpoint_descriptor as_iso_out_desc = {
 222	.bLength =		UAC_ISO_ENDPOINT_DESC_SIZE,
 223	.bDescriptorType =	USB_DT_CS_ENDPOINT,
 224	.bDescriptorSubtype =	UAC_EP_GENERAL,
 225	.bmAttributes =		1,
 226	.bLockDelayUnits =	1,
 227	.wLockDelay =		cpu_to_le16(1),
 228};
 229
 230static struct uac_format_type_i_discrete_descriptor as_in_type_i_desc = {
 231	.bLength =		0, /* filled on rate setup */
 232	.bDescriptorType =	USB_DT_CS_INTERFACE,
 233	.bDescriptorSubtype =	UAC_FORMAT_TYPE,
 234	.bFormatType =		UAC_FORMAT_TYPE_I,
 235	.bSubframeSize =	2,
 236	.bBitResolution =	16,
 237	.bSamFreqType =		0, /* filled on rate setup */
 238};
 239
 240/* Standard ISO OUT Endpoint Descriptor */
 241static struct usb_endpoint_descriptor as_in_ep_desc  = {
 242	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
 243	.bDescriptorType =	USB_DT_ENDPOINT,
 244	.bEndpointAddress =	USB_DIR_IN,
 245	.bmAttributes =		USB_ENDPOINT_SYNC_ASYNC
 246				| USB_ENDPOINT_XFER_ISOC,
 247	.wMaxPacketSize	=	cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
 248	.bInterval =		4,
 249};
 250
 251/* Class-specific AS ISO OUT Endpoint Descriptor */
 252static struct uac_iso_endpoint_descriptor as_iso_in_desc = {
 253	.bLength =		UAC_ISO_ENDPOINT_DESC_SIZE,
 254	.bDescriptorType =	USB_DT_CS_ENDPOINT,
 255	.bDescriptorSubtype =	UAC_EP_GENERAL,
 256	.bmAttributes =		1,
 257	.bLockDelayUnits =	0,
 258	.wLockDelay =		0,
 259};
 260
 261static struct usb_descriptor_header *f_audio_desc[] = {
 262	(struct usb_descriptor_header *)&ac_interface_desc,
 263	(struct usb_descriptor_header *)&ac_header_desc,
 264
 265	(struct usb_descriptor_header *)&usb_out_it_desc,
 266	(struct usb_descriptor_header *)&io_out_ot_desc,
 267	(struct usb_descriptor_header *)&out_feature_unit_desc,
 268
 269	(struct usb_descriptor_header *)&io_in_it_desc,
 270	(struct usb_descriptor_header *)&usb_in_ot_desc,
 271	(struct usb_descriptor_header *)&in_feature_unit_desc,
 272
 273	(struct usb_descriptor_header *)&ac_int_ep_desc,
 274
 275	(struct usb_descriptor_header *)&as_out_interface_alt_0_desc,
 276	(struct usb_descriptor_header *)&as_out_interface_alt_1_desc,
 277	(struct usb_descriptor_header *)&as_out_header_desc,
 278
 279	(struct usb_descriptor_header *)&as_out_type_i_desc,
 280
 281	(struct usb_descriptor_header *)&as_out_ep_desc,
 282	(struct usb_descriptor_header *)&as_iso_out_desc,
 283
 284	(struct usb_descriptor_header *)&as_in_interface_alt_0_desc,
 285	(struct usb_descriptor_header *)&as_in_interface_alt_1_desc,
 286	(struct usb_descriptor_header *)&as_in_header_desc,
 287
 288	(struct usb_descriptor_header *)&as_in_type_i_desc,
 289
 290	(struct usb_descriptor_header *)&as_in_ep_desc,
 291	(struct usb_descriptor_header *)&as_iso_in_desc,
 292	NULL,
 293};
 294
 295/* Standard ISO OUT Endpoint Descriptor */
 296static struct usb_endpoint_descriptor ss_as_out_ep_desc  = {
 297	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
 298	.bDescriptorType =	USB_DT_ENDPOINT,
 299	.bEndpointAddress =	USB_DIR_OUT,
 300	.bmAttributes =		USB_ENDPOINT_SYNC_ADAPTIVE
 301				| USB_ENDPOINT_XFER_ISOC,
 302	.wMaxPacketSize	=	cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
 303	.bInterval =		4,
 304};
 305
 306static struct usb_ss_ep_comp_descriptor ss_as_out_ep_desc_comp = {
 307	.bLength		= sizeof(ss_as_out_ep_desc_comp),
 308	.bDescriptorType	= USB_DT_SS_ENDPOINT_COMP,
 309	.bMaxBurst		= 0,
 310	.bmAttributes		= 0,
 311	/* wBytesPerInterval = DYNAMIC */
 312};
 313
 314/* Standard ISO OUT Endpoint Descriptor */
 315static struct usb_endpoint_descriptor ss_as_in_ep_desc  = {
 316	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
 317	.bDescriptorType =	USB_DT_ENDPOINT,
 318	.bEndpointAddress =	USB_DIR_IN,
 319	.bmAttributes =		USB_ENDPOINT_SYNC_ASYNC
 320				| USB_ENDPOINT_XFER_ISOC,
 321	.wMaxPacketSize	=	cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
 322	.bInterval =		4,
 323};
 324
 325static struct usb_ss_ep_comp_descriptor ss_as_in_ep_desc_comp = {
 326	.bLength		= sizeof(ss_as_in_ep_desc_comp),
 327	.bDescriptorType	= USB_DT_SS_ENDPOINT_COMP,
 328	.bMaxBurst		= 0,
 329	.bmAttributes		= 0,
 330	/* wBytesPerInterval = DYNAMIC */
 331};
 332
 333static struct usb_descriptor_header *f_audio_ss_desc[] = {
 334	(struct usb_descriptor_header *)&ac_interface_desc,
 335	(struct usb_descriptor_header *)&ac_header_desc,
 336
 337	(struct usb_descriptor_header *)&usb_out_it_desc,
 338	(struct usb_descriptor_header *)&io_out_ot_desc,
 339	(struct usb_descriptor_header *)&io_in_it_desc,
 340	(struct usb_descriptor_header *)&usb_in_ot_desc,
 341
 342	(struct usb_descriptor_header *)&as_out_interface_alt_0_desc,
 343	(struct usb_descriptor_header *)&as_out_interface_alt_1_desc,
 344	(struct usb_descriptor_header *)&as_out_header_desc,
 345
 346	(struct usb_descriptor_header *)&as_out_type_i_desc,
 347
 348	//(struct usb_descriptor_header *)&as_out_ep_desc,
 349	(struct usb_descriptor_header *)&ss_as_out_ep_desc,
 350	(struct usb_descriptor_header *)&ss_as_out_ep_desc_comp,
 351	(struct usb_descriptor_header *)&as_iso_out_desc,
 352
 353	(struct usb_descriptor_header *)&as_in_interface_alt_0_desc,
 354	(struct usb_descriptor_header *)&as_in_interface_alt_1_desc,
 355	(struct usb_descriptor_header *)&as_in_header_desc,
 356
 357	(struct usb_descriptor_header *)&as_in_type_i_desc,
 358
 359	//(struct usb_descriptor_header *)&as_in_ep_desc,
 360	(struct usb_descriptor_header *)&ss_as_in_ep_desc,
 361	(struct usb_descriptor_header *)&ss_as_in_ep_desc_comp,
 362	(struct usb_descriptor_header *)&as_iso_in_desc,
 363	NULL,
 364};
 365
 366enum {
 367	STR_AC_IF,
 368	STR_USB_OUT_IT,
 369	STR_USB_OUT_IT_CH_NAMES,
 370	STR_IO_OUT_OT,
 371	STR_IO_IN_IT,
 372	STR_IO_IN_IT_CH_NAMES,
 373	STR_USB_IN_OT,
 374	STR_FU_IN,
 375	STR_FU_OUT,
 376	STR_AS_OUT_IF_ALT0,
 377	STR_AS_OUT_IF_ALT1,
 378	STR_AS_IN_IF_ALT0,
 379	STR_AS_IN_IF_ALT1,
 
 380};
 381
 382static struct usb_string strings_uac1[] = {
 383	/* [STR_AC_IF].s = DYNAMIC, */
 384	[STR_USB_OUT_IT].s = "Playback Input terminal",
 385	[STR_USB_OUT_IT_CH_NAMES].s = "Playback Channels",
 386	[STR_IO_OUT_OT].s = "Playback Output terminal",
 387	[STR_IO_IN_IT].s = "Capture Input terminal",
 388	[STR_IO_IN_IT_CH_NAMES].s = "Capture Channels",
 389	[STR_USB_IN_OT].s = "Capture Output terminal",
 390	[STR_FU_IN].s = "Capture Volume",
 391	[STR_FU_OUT].s = "Playback Volume",
 392	[STR_AS_OUT_IF_ALT0].s = "Playback Inactive",
 393	[STR_AS_OUT_IF_ALT1].s = "Playback Active",
 394	[STR_AS_IN_IF_ALT0].s = "Capture Inactive",
 395	[STR_AS_IN_IF_ALT1].s = "Capture Active",
 396	{ },
 397};
 398
 399static struct usb_gadget_strings str_uac1 = {
 400	.language = 0x0409,	/* en-us */
 401	.strings = strings_uac1,
 402};
 403
 404static struct usb_gadget_strings *uac1_strings[] = {
 405	&str_uac1,
 406	NULL,
 407};
 408
 409/*
 410 * This function is an ALSA sound card following USB Audio Class Spec 1.0.
 411 */
 412
 413static void uac_cs_attr_sample_rate(struct usb_ep *ep, struct usb_request *req)
 414{
 415	struct usb_function *fn = ep->driver_data;
 416	struct usb_composite_dev *cdev = fn->config->cdev;
 417	struct g_audio *agdev = func_to_g_audio(fn);
 418	struct f_uac1 *uac1 = func_to_uac1(fn);
 419	u8 *buf = (u8 *)req->buf;
 420	u32 val = 0;
 421
 422	if (req->actual != 3) {
 423		WARN(cdev, "Invalid data size for UAC_EP_CS_ATTR_SAMPLE_RATE.\n");
 424		return;
 425	}
 426
 427	val = buf[0] | (buf[1] << 8) | (buf[2] << 16);
 428	if (uac1->ctl_id == (USB_DIR_IN | 2)) {
 429		uac1->p_srate = val;
 430		u_audio_set_playback_srate(agdev, uac1->p_srate);
 431	} else if (uac1->ctl_id == (USB_DIR_OUT | 1)) {
 432		uac1->c_srate = val;
 433		u_audio_set_capture_srate(agdev, uac1->c_srate);
 434	}
 435}
 436
 437static void audio_notify_complete(struct usb_ep *_ep, struct usb_request *req)
 438{
 439	struct g_audio *audio = req->context;
 440	struct f_uac1 *uac1 = func_to_uac1(&audio->func);
 441
 442	atomic_dec(&uac1->int_count);
 443	kfree(req->buf);
 444	usb_ep_free_request(_ep, req);
 445}
 446
 447static int audio_notify(struct g_audio *audio, int unit_id, int cs)
 448{
 449	struct f_uac1 *uac1 = func_to_uac1(&audio->func);
 450	struct usb_request *req;
 451	struct uac1_status_word *msg;
 452	int ret;
 453
 454	if (!uac1->int_ep->enabled)
 455		return 0;
 456
 457	if (atomic_inc_return(&uac1->int_count) > UAC1_DEF_INT_REQ_NUM) {
 458		atomic_dec(&uac1->int_count);
 459		return 0;
 460	}
 461
 462	req = usb_ep_alloc_request(uac1->int_ep, GFP_ATOMIC);
 463	if (req == NULL) {
 464		ret = -ENOMEM;
 465		goto err_dec_int_count;
 466	}
 467
 468	msg = kmalloc(sizeof(*msg), GFP_ATOMIC);
 469	if (msg == NULL) {
 470		ret = -ENOMEM;
 471		goto err_free_request;
 472	}
 473
 474	msg->bStatusType = UAC1_STATUS_TYPE_IRQ_PENDING
 475				| UAC1_STATUS_TYPE_ORIG_AUDIO_CONTROL_IF;
 476	msg->bOriginator = unit_id;
 477
 478	req->length = sizeof(*msg);
 479	req->buf = msg;
 480	req->context = audio;
 481	req->complete = audio_notify_complete;
 482
 483	ret = usb_ep_queue(uac1->int_ep, req, GFP_ATOMIC);
 484
 485	if (ret)
 486		goto err_free_msg;
 487
 488	return 0;
 489
 490err_free_msg:
 491	kfree(msg);
 492err_free_request:
 493	usb_ep_free_request(uac1->int_ep, req);
 494err_dec_int_count:
 495	atomic_dec(&uac1->int_count);
 496
 497	return ret;
 498}
 499
 500static int
 501in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 502{
 503	struct usb_request *req = fn->config->cdev->req;
 504	struct g_audio *audio = func_to_g_audio(fn);
 505	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 506	u16 w_length = le16_to_cpu(cr->wLength);
 507	u16 w_index = le16_to_cpu(cr->wIndex);
 508	u16 w_value = le16_to_cpu(cr->wValue);
 509	u8 entity_id = (w_index >> 8) & 0xff;
 510	u8 control_selector = w_value >> 8;
 511	int value = -EOPNOTSUPP;
 512
 513	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
 514			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
 515		unsigned int is_playback = 0;
 516
 517		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
 518			is_playback = 1;
 519
 520		if (control_selector == UAC_FU_MUTE) {
 521			unsigned int mute;
 522
 523			u_audio_get_mute(audio, is_playback, &mute);
 524
 525			*(u8 *)req->buf = mute;
 526			value = min_t(unsigned int, w_length, 1);
 527		} else if (control_selector == UAC_FU_VOLUME) {
 528			__le16 c;
 529			s16 volume;
 530
 531			u_audio_get_volume(audio, is_playback, &volume);
 532
 533			c = cpu_to_le16(volume);
 534
 535			value = min_t(unsigned int, w_length, sizeof(c));
 536			memcpy(req->buf, &c, value);
 537		} else {
 538			dev_err(&audio->gadget->dev,
 539				"%s:%d control_selector=%d TODO!\n",
 540				__func__, __LINE__, control_selector);
 541		}
 542	} else {
 543		dev_err(&audio->gadget->dev,
 544			"%s:%d entity_id=%d control_selector=%d TODO!\n",
 545			__func__, __LINE__, entity_id, control_selector);
 546	}
 547
 548	return value;
 549}
 550
 551static int
 552in_rq_min(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 553{
 554	struct usb_request *req = fn->config->cdev->req;
 555	struct g_audio *audio = func_to_g_audio(fn);
 556	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 557	u16 w_length = le16_to_cpu(cr->wLength);
 558	u16 w_index = le16_to_cpu(cr->wIndex);
 559	u16 w_value = le16_to_cpu(cr->wValue);
 560	u8 entity_id = (w_index >> 8) & 0xff;
 561	u8 control_selector = w_value >> 8;
 562	int value = -EOPNOTSUPP;
 563
 564	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
 565			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
 566		unsigned int is_playback = 0;
 567
 568		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
 569			is_playback = 1;
 570
 571		if (control_selector == UAC_FU_VOLUME) {
 572			__le16 r;
 573			s16 min_db;
 574
 575			if (is_playback)
 576				min_db = opts->p_volume_min;
 577			else
 578				min_db = opts->c_volume_min;
 579
 580			r = cpu_to_le16(min_db);
 581
 582			value = min_t(unsigned int, w_length, sizeof(r));
 583			memcpy(req->buf, &r, value);
 584		} else {
 585			dev_err(&audio->gadget->dev,
 586				"%s:%d control_selector=%d TODO!\n",
 587				__func__, __LINE__, control_selector);
 588		}
 589	} else {
 590		dev_err(&audio->gadget->dev,
 591			"%s:%d entity_id=%d control_selector=%d TODO!\n",
 592			__func__, __LINE__, entity_id, control_selector);
 593	}
 594
 595	return value;
 596}
 597
 598static int
 599in_rq_max(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 600{
 601	struct usb_request *req = fn->config->cdev->req;
 602	struct g_audio *audio = func_to_g_audio(fn);
 603	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 604	u16 w_length = le16_to_cpu(cr->wLength);
 605	u16 w_index = le16_to_cpu(cr->wIndex);
 606	u16 w_value = le16_to_cpu(cr->wValue);
 607	u8 entity_id = (w_index >> 8) & 0xff;
 608	u8 control_selector = w_value >> 8;
 609	int value = -EOPNOTSUPP;
 610
 611	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
 612			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
 613		unsigned int is_playback = 0;
 614
 615		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
 616			is_playback = 1;
 617
 618		if (control_selector == UAC_FU_VOLUME) {
 619			__le16 r;
 620			s16 max_db;
 621
 622			if (is_playback)
 623				max_db = opts->p_volume_max;
 624			else
 625				max_db = opts->c_volume_max;
 626
 627			r = cpu_to_le16(max_db);
 628
 629			value = min_t(unsigned int, w_length, sizeof(r));
 630			memcpy(req->buf, &r, value);
 631		} else {
 632			dev_err(&audio->gadget->dev,
 633				"%s:%d control_selector=%d TODO!\n",
 634				__func__, __LINE__, control_selector);
 635		}
 636	} else {
 637		dev_err(&audio->gadget->dev,
 638			"%s:%d entity_id=%d control_selector=%d TODO!\n",
 639			__func__, __LINE__, entity_id, control_selector);
 640	}
 641
 642	return value;
 643}
 644
 645static int
 646in_rq_res(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 647{
 648	struct usb_request *req = fn->config->cdev->req;
 649	struct g_audio *audio = func_to_g_audio(fn);
 650	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 651	u16 w_length = le16_to_cpu(cr->wLength);
 652	u16 w_index = le16_to_cpu(cr->wIndex);
 653	u16 w_value = le16_to_cpu(cr->wValue);
 654	u8 entity_id = (w_index >> 8) & 0xff;
 655	u8 control_selector = w_value >> 8;
 656	int value = -EOPNOTSUPP;
 657
 658	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
 659			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
 660		unsigned int is_playback = 0;
 661
 662		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
 663			is_playback = 1;
 664
 665		if (control_selector == UAC_FU_VOLUME) {
 666			__le16 r;
 667			s16 res_db;
 668
 669			if (is_playback)
 670				res_db = opts->p_volume_res;
 671			else
 672				res_db = opts->c_volume_res;
 673
 674			r = cpu_to_le16(res_db);
 675
 676			value = min_t(unsigned int, w_length, sizeof(r));
 677			memcpy(req->buf, &r, value);
 678		} else {
 679			dev_err(&audio->gadget->dev,
 680				"%s:%d control_selector=%d TODO!\n",
 681				__func__, __LINE__, control_selector);
 682		}
 683	} else {
 684		dev_err(&audio->gadget->dev,
 685			"%s:%d entity_id=%d control_selector=%d TODO!\n",
 686			__func__, __LINE__, entity_id, control_selector);
 687	}
 688
 689	return value;
 690}
 691
 692static void
 693out_rq_cur_complete(struct usb_ep *ep, struct usb_request *req)
 694{
 695	struct g_audio *audio = req->context;
 696	struct usb_composite_dev *cdev = audio->func.config->cdev;
 697	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 698	struct f_uac1 *uac1 = func_to_uac1(&audio->func);
 699	struct usb_ctrlrequest *cr = &uac1->setup_cr;
 700	u16 w_index = le16_to_cpu(cr->wIndex);
 701	u16 w_value = le16_to_cpu(cr->wValue);
 702	u8 entity_id = (w_index >> 8) & 0xff;
 703	u8 control_selector = w_value >> 8;
 704
 705	if (req->status != 0) {
 706		dev_dbg(&cdev->gadget->dev, "completion err %d\n", req->status);
 707		return;
 708	}
 709
 710	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
 711			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
 712		unsigned int is_playback = 0;
 713
 714		if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
 715			is_playback = 1;
 716
 717		if (control_selector == UAC_FU_MUTE) {
 718			u8 mute = *(u8 *)req->buf;
 719
 720			u_audio_set_mute(audio, is_playback, mute);
 721
 722			return;
 723		} else if (control_selector == UAC_FU_VOLUME) {
 724			__le16 *c = req->buf;
 725			s16 volume;
 726
 727			volume = le16_to_cpu(*c);
 728			u_audio_set_volume(audio, is_playback, volume);
 729
 730			return;
 731		} else {
 732			dev_err(&audio->gadget->dev,
 733				"%s:%d control_selector=%d TODO!\n",
 734				__func__, __LINE__, control_selector);
 735			usb_ep_set_halt(ep);
 736		}
 737	} else {
 738		dev_err(&audio->gadget->dev,
 739			"%s:%d entity_id=%d control_selector=%d TODO!\n",
 740			__func__, __LINE__, entity_id, control_selector);
 741		usb_ep_set_halt(ep);
 742
 743	}
 744}
 745
 746static int
 747out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
 748{
 749	struct usb_request *req = fn->config->cdev->req;
 750	struct g_audio *audio = func_to_g_audio(fn);
 751	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
 752	struct f_uac1 *uac1 = func_to_uac1(&audio->func);
 753	u16 w_length = le16_to_cpu(cr->wLength);
 754	u16 w_index = le16_to_cpu(cr->wIndex);
 755	u16 w_value = le16_to_cpu(cr->wValue);
 756	u8 entity_id = (w_index >> 8) & 0xff;
 757	u8 control_selector = w_value >> 8;
 758
 759	if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
 760			(FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
 761		memcpy(&uac1->setup_cr, cr, sizeof(*cr));
 762		req->context = audio;
 763		req->complete = out_rq_cur_complete;
 764
 765		return w_length;
 766	} else {
 767		dev_err(&audio->gadget->dev,
 768			"%s:%d entity_id=%d control_selector=%d TODO!\n",
 769			__func__, __LINE__, entity_id, control_selector);
 770	}
 771	return -EOPNOTSUPP;
 772}
 773
 774static int ac_rq_in(struct usb_function *f,
 775		const struct usb_ctrlrequest *ctrl)
 776{
 777	struct usb_composite_dev *cdev = f->config->cdev;
 778	int value = -EOPNOTSUPP;
 779	u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
 780	u16 len = le16_to_cpu(ctrl->wLength);
 781	u16 w_value = le16_to_cpu(ctrl->wValue);
 782
 783	DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
 784			ctrl->bRequest, w_value, len, ep);
 785
 786	switch (ctrl->bRequest) {
 787	case UAC_GET_CUR:
 788		return in_rq_cur(f, ctrl);
 789	case UAC_GET_MIN:
 790		return in_rq_min(f, ctrl);
 791	case UAC_GET_MAX:
 792		return in_rq_max(f, ctrl);
 793	case UAC_GET_RES:
 794		return in_rq_res(f, ctrl);
 795	case UAC_GET_MEM:
 796		break;
 797	case UAC_GET_STAT:
 798		value = len;
 799		break;
 800	default:
 801		break;
 802	}
 803
 804	return value;
 805}
 806
 807static int audio_set_endpoint_req(struct usb_function *f,
 808		const struct usb_ctrlrequest *ctrl)
 809{
 810	struct usb_composite_dev *cdev = f->config->cdev;
 811	struct usb_request	*req = f->config->cdev->req;
 812	struct f_uac1		*uac1 = func_to_uac1(f);
 813	int			value = -EOPNOTSUPP;
 814	u16			ep = le16_to_cpu(ctrl->wIndex);
 815	u16			len = le16_to_cpu(ctrl->wLength);
 816	u16			w_value = le16_to_cpu(ctrl->wValue);
 817	u8			cs = w_value >> 8;
 818
 819	DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
 820			ctrl->bRequest, w_value, len, ep);
 821
 822	switch (ctrl->bRequest) {
 823	case UAC_SET_CUR: {
 824		if (cs == UAC_EP_CS_ATTR_SAMPLE_RATE) {
 825			cdev->gadget->ep0->driver_data = f;
 826			uac1->ctl_id = ep;
 827			req->complete = uac_cs_attr_sample_rate;
 828		}
 829		value = len;
 830		break;
 831	}
 832
 833	case UAC_SET_MIN:
 834		break;
 835
 836	case UAC_SET_MAX:
 837		break;
 838
 839	case UAC_SET_RES:
 840		break;
 841
 842	case UAC_SET_MEM:
 843		break;
 844
 845	default:
 846		break;
 847	}
 848
 849	return value;
 850}
 851
 852static int audio_get_endpoint_req(struct usb_function *f,
 853		const struct usb_ctrlrequest *ctrl)
 854{
 855	struct usb_composite_dev *cdev = f->config->cdev;
 856	struct usb_request *req = f->config->cdev->req;
 857	struct f_uac1 *uac1 = func_to_uac1(f);
 858	u8 *buf = (u8 *)req->buf;
 859	int value = -EOPNOTSUPP;
 860	u8 ep = le16_to_cpu(ctrl->wIndex);
 861	u16 len = le16_to_cpu(ctrl->wLength);
 862	u16 w_value = le16_to_cpu(ctrl->wValue);
 863	u8 cs = w_value >> 8;
 864	u32 val = 0;
 865
 866	DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
 867			ctrl->bRequest, w_value, len, ep);
 868
 869	switch (ctrl->bRequest) {
 870	case UAC_GET_CUR: {
 871		if (cs == UAC_EP_CS_ATTR_SAMPLE_RATE) {
 872			if (ep == (USB_DIR_IN | 2))
 873				val = uac1->p_srate;
 874			else if (ep == (USB_DIR_OUT | 1))
 875				val = uac1->c_srate;
 876			buf[2] = (val >> 16) & 0xff;
 877			buf[1] = (val >> 8) & 0xff;
 878			buf[0] = val & 0xff;
 879		}
 880		value = len;
 881		break;
 882	}
 883	case UAC_GET_MIN:
 884	case UAC_GET_MAX:
 885	case UAC_GET_RES:
 886		value = len;
 887		break;
 888	case UAC_GET_MEM:
 889		break;
 890	default:
 891		break;
 892	}
 893
 894	return value;
 895}
 896
 897static int
 898f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
 899{
 900	struct usb_composite_dev *cdev = f->config->cdev;
 901	struct usb_request	*req = cdev->req;
 902	int			value = -EOPNOTSUPP;
 903	u16			w_index = le16_to_cpu(ctrl->wIndex);
 904	u16			w_value = le16_to_cpu(ctrl->wValue);
 905	u16			w_length = le16_to_cpu(ctrl->wLength);
 906
 907	/* composite driver infrastructure handles everything; interface
 908	 * activation uses set_alt().
 909	 */
 910	switch (ctrl->bRequestType) {
 911	case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
 912		value = audio_set_endpoint_req(f, ctrl);
 913		break;
 914
 915	case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
 916		value = audio_get_endpoint_req(f, ctrl);
 917		break;
 918	case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
 919		if (ctrl->bRequest == UAC_SET_CUR)
 920			value = out_rq_cur(f, ctrl);
 921		break;
 922	case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE:
 923		value = ac_rq_in(f, ctrl);
 924		break;
 925	default:
 926		ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
 927			ctrl->bRequestType, ctrl->bRequest,
 928			w_value, w_index, w_length);
 929	}
 930
 931	/* respond with data transfer or status phase? */
 932	if (value >= 0) {
 933		DBG(cdev, "audio req%02x.%02x v%04x i%04x l%d\n",
 934			ctrl->bRequestType, ctrl->bRequest,
 935			w_value, w_index, w_length);
 936		req->zero = 0;
 937		req->length = value;
 938		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
 939		if (value < 0)
 940			ERROR(cdev, "audio response on err %d\n", value);
 941	}
 942
 943	/* device either stalls (value < 0) or reports success */
 944	return value;
 945}
 946
 947static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
 948{
 949	struct usb_composite_dev *cdev = f->config->cdev;
 950	struct usb_gadget *gadget = cdev->gadget;
 951	struct device *dev = &gadget->dev;
 952	struct g_audio *audio = func_to_g_audio(f);
 953	struct f_uac1 *uac1 = func_to_uac1(f);
 954	int ret = 0;
 955
 956	/* No i/f has more than 2 alt settings */
 957	if (alt > 1) {
 958		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 959		return -EINVAL;
 960	}
 961
 962	if (intf == uac1->ac_intf) {
 963		/* Control I/f has only 1 AltSetting - 0 */
 964		if (alt) {
 965			dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 966			return -EINVAL;
 967		}
 968
 969		/* restart interrupt endpoint */
 970		if (uac1->int_ep) {
 971			usb_ep_disable(uac1->int_ep);
 972			config_ep_by_speed(gadget, &audio->func, uac1->int_ep);
 973			usb_ep_enable(uac1->int_ep);
 974		}
 975
 976		return 0;
 977	}
 978
 979	if (intf == uac1->as_out_intf) {
 980		uac1->as_out_alt = alt;
 981
 982		if (alt)
 983			ret = u_audio_start_capture(&uac1->g_audio);
 984		else
 985			u_audio_stop_capture(&uac1->g_audio);
 986	} else if (intf == uac1->as_in_intf) {
 987		uac1->as_in_alt = alt;
 988
 989		if (alt)
 990			ret = u_audio_start_playback(&uac1->g_audio);
 991		else
 992			u_audio_stop_playback(&uac1->g_audio);
 993	} else {
 994		dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 995		return -EINVAL;
 996	}
 997
 998	return ret;
 999}
1000
1001static int f_audio_get_alt(struct usb_function *f, unsigned intf)
1002{
1003	struct usb_composite_dev *cdev = f->config->cdev;
1004	struct usb_gadget *gadget = cdev->gadget;
1005	struct device *dev = &gadget->dev;
1006	struct f_uac1 *uac1 = func_to_uac1(f);
1007
1008	if (intf == uac1->ac_intf)
1009		return uac1->ac_alt;
1010	else if (intf == uac1->as_out_intf)
1011		return uac1->as_out_alt;
1012	else if (intf == uac1->as_in_intf)
1013		return uac1->as_in_alt;
1014	else
1015		dev_err(dev, "%s:%d Invalid Interface %d!\n",
1016			__func__, __LINE__, intf);
1017
1018	return -EINVAL;
1019}
1020
1021
1022static void f_audio_disable(struct usb_function *f)
1023{
1024	struct f_uac1 *uac1 = func_to_uac1(f);
1025
1026	uac1->as_out_alt = 0;
1027	uac1->as_in_alt = 0;
1028
1029	u_audio_stop_playback(&uac1->g_audio);
1030	u_audio_stop_capture(&uac1->g_audio);
1031	if (uac1->int_ep)
1032		usb_ep_disable(uac1->int_ep);
1033}
1034
1035static void
1036f_audio_suspend(struct usb_function *f)
1037{
1038	struct f_uac1 *uac1 = func_to_uac1(f);
1039
1040	u_audio_suspend(&uac1->g_audio);
1041}
1042
1043/*-------------------------------------------------------------------------*/
1044static struct uac_feature_unit_descriptor *build_fu_desc(int chmask)
1045{
1046	struct uac_feature_unit_descriptor *fu_desc;
1047	int channels = num_channels(chmask);
1048	int fu_desc_size = UAC_DT_FEATURE_UNIT_SIZE(channels);
1049
1050	fu_desc = kzalloc(fu_desc_size, GFP_KERNEL);
1051	if (!fu_desc)
1052		return NULL;
1053
1054	fu_desc->bLength = fu_desc_size;
1055	fu_desc->bDescriptorType = USB_DT_CS_INTERFACE;
1056
1057	fu_desc->bDescriptorSubtype = UAC_FEATURE_UNIT;
1058	fu_desc->bControlSize  = 2;
1059
1060	/* bUnitID, bSourceID and bmaControls will be defined later */
1061
1062	return fu_desc;
1063}
1064
1065/* B.3.2  Class-Specific AC Interface Descriptor */
1066static struct
1067uac1_ac_header_descriptor *build_ac_header_desc(struct f_uac1_opts *opts)
1068{
1069	struct uac1_ac_header_descriptor *ac_desc;
1070	int ac_header_desc_size;
1071	int num_ifaces = 0;
1072
1073	if (EPOUT_EN(opts))
1074		num_ifaces++;
1075	if (EPIN_EN(opts))
1076		num_ifaces++;
1077
1078	ac_header_desc_size = UAC_DT_AC_HEADER_SIZE(num_ifaces);
1079
1080	ac_desc = kzalloc(ac_header_desc_size, GFP_KERNEL);
1081	if (!ac_desc)
1082		return NULL;
1083
1084	ac_desc->bLength = ac_header_desc_size;
1085	ac_desc->bDescriptorType = USB_DT_CS_INTERFACE;
1086	ac_desc->bDescriptorSubtype = UAC_HEADER;
1087	ac_desc->bcdADC = cpu_to_le16(0x0100);
1088	ac_desc->bInCollection = num_ifaces;
1089
1090	/* wTotalLength and baInterfaceNr will be defined later */
1091
1092	return ac_desc;
1093}
1094
1095/* Use macro to overcome line length limitation */
1096#define USBDHDR(p) (struct usb_descriptor_header *)(p)
1097
1098static void setup_descriptor(struct f_uac1_opts *opts)
1099{
1100	/* patch descriptors */
1101	int i = 1; /* ID's start with 1 */
1102
1103	if (EPOUT_EN(opts))
1104		usb_out_it_desc.bTerminalID = i++;
1105	if (EPIN_EN(opts))
1106		io_in_it_desc.bTerminalID = i++;
1107	if (EPOUT_EN(opts))
1108		io_out_ot_desc.bTerminalID = i++;
1109	if (EPIN_EN(opts))
1110		usb_in_ot_desc.bTerminalID = i++;
1111	if (FUOUT_EN(opts))
1112		out_feature_unit_desc->bUnitID = i++;
1113	if (FUIN_EN(opts))
1114		in_feature_unit_desc->bUnitID = i++;
1115
1116	if (FUIN_EN(opts)) {
1117		usb_in_ot_desc.bSourceID = in_feature_unit_desc->bUnitID;
1118		in_feature_unit_desc->bSourceID = io_in_it_desc.bTerminalID;
1119	} else {
1120		usb_in_ot_desc.bSourceID = io_in_it_desc.bTerminalID;
1121	}
1122	if (FUOUT_EN(opts)) {
1123		io_out_ot_desc.bSourceID = out_feature_unit_desc->bUnitID;
1124		out_feature_unit_desc->bSourceID = usb_out_it_desc.bTerminalID;
1125	} else {
1126		io_out_ot_desc.bSourceID = usb_out_it_desc.bTerminalID;
1127	}
1128
1129	as_out_header_desc.bTerminalLink = usb_out_it_desc.bTerminalID;
1130	as_in_header_desc.bTerminalLink = usb_in_ot_desc.bTerminalID;
1131
1132	ac_header_desc->wTotalLength = cpu_to_le16(ac_header_desc->bLength);
1133
1134	if (EPIN_EN(opts)) {
1135		u16 len = le16_to_cpu(ac_header_desc->wTotalLength);
1136
1137		len += sizeof(usb_in_ot_desc);
1138		len += sizeof(io_in_it_desc);
1139		if (FUIN_EN(opts))
1140			len += in_feature_unit_desc->bLength;
1141		ac_header_desc->wTotalLength = cpu_to_le16(len);
1142	}
1143	if (EPOUT_EN(opts)) {
1144		u16 len = le16_to_cpu(ac_header_desc->wTotalLength);
1145
1146		len += sizeof(usb_out_it_desc);
1147		len += sizeof(io_out_ot_desc);
1148		if (FUOUT_EN(opts))
1149			len += out_feature_unit_desc->bLength;
1150		ac_header_desc->wTotalLength = cpu_to_le16(len);
1151	}
1152
1153	i = 0;
1154	f_audio_desc[i++] = USBDHDR(&ac_interface_desc);
1155	f_audio_desc[i++] = USBDHDR(ac_header_desc);
1156
1157	if (EPOUT_EN(opts)) {
1158		f_audio_desc[i++] = USBDHDR(&usb_out_it_desc);
1159		f_audio_desc[i++] = USBDHDR(&io_out_ot_desc);
1160		if (FUOUT_EN(opts))
1161			f_audio_desc[i++] = USBDHDR(out_feature_unit_desc);
1162	}
1163
1164	if (EPIN_EN(opts)) {
1165		f_audio_desc[i++] = USBDHDR(&io_in_it_desc);
1166		f_audio_desc[i++] = USBDHDR(&usb_in_ot_desc);
1167		if (FUIN_EN(opts))
1168			f_audio_desc[i++] = USBDHDR(in_feature_unit_desc);
1169	}
1170
1171	if (FUOUT_EN(opts) || FUIN_EN(opts))
1172		f_audio_desc[i++] = USBDHDR(&ac_int_ep_desc);
1173
1174	if (EPOUT_EN(opts)) {
1175		f_audio_desc[i++] = USBDHDR(&as_out_interface_alt_0_desc);
1176		f_audio_desc[i++] = USBDHDR(&as_out_interface_alt_1_desc);
1177		f_audio_desc[i++] = USBDHDR(&as_out_header_desc);
1178		f_audio_desc[i++] = USBDHDR(&as_out_type_i_desc);
1179		f_audio_desc[i++] = USBDHDR(&as_out_ep_desc);
1180		f_audio_desc[i++] = USBDHDR(&as_iso_out_desc);
1181	}
1182	if (EPIN_EN(opts)) {
1183		f_audio_desc[i++] = USBDHDR(&as_in_interface_alt_0_desc);
1184		f_audio_desc[i++] = USBDHDR(&as_in_interface_alt_1_desc);
1185		f_audio_desc[i++] = USBDHDR(&as_in_header_desc);
1186		f_audio_desc[i++] = USBDHDR(&as_in_type_i_desc);
1187		f_audio_desc[i++] = USBDHDR(&as_in_ep_desc);
1188		f_audio_desc[i++] = USBDHDR(&as_iso_in_desc);
1189	}
1190	f_audio_desc[i] = NULL;
1191}
1192
1193static int f_audio_validate_opts(struct g_audio *audio, struct device *dev)
1194{
1195	struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
1196
1197	if (!opts->p_chmask && !opts->c_chmask) {
1198		dev_err(dev, "Error: no playback and capture channels\n");
1199		return -EINVAL;
1200	} else if (opts->p_chmask & ~UAC1_CHANNEL_MASK) {
1201		dev_err(dev, "Error: unsupported playback channels mask\n");
1202		return -EINVAL;
1203	} else if (opts->c_chmask & ~UAC1_CHANNEL_MASK) {
1204		dev_err(dev, "Error: unsupported capture channels mask\n");
1205		return -EINVAL;
1206	} else if ((opts->p_ssize < 1) || (opts->p_ssize > 4)) {
1207		dev_err(dev, "Error: incorrect playback sample size\n");
1208		return -EINVAL;
1209	} else if ((opts->c_ssize < 1) || (opts->c_ssize > 4)) {
1210		dev_err(dev, "Error: incorrect capture sample size\n");
1211		return -EINVAL;
1212	} else if (!opts->p_srates[0]) {
1213		dev_err(dev, "Error: incorrect playback sampling rate\n");
1214		return -EINVAL;
1215	} else if (!opts->c_srates[0]) {
1216		dev_err(dev, "Error: incorrect capture sampling rate\n");
1217		return -EINVAL;
1218	}
1219
1220	if (opts->p_volume_max <= opts->p_volume_min) {
1221		dev_err(dev, "Error: incorrect playback volume max/min\n");
1222		return -EINVAL;
1223	} else if (opts->c_volume_max <= opts->c_volume_min) {
1224		dev_err(dev, "Error: incorrect capture volume max/min\n");
1225		return -EINVAL;
1226	} else if (opts->p_volume_res <= 0) {
1227		dev_err(dev, "Error: negative/zero playback volume resolution\n");
1228		return -EINVAL;
1229	} else if (opts->c_volume_res <= 0) {
1230		dev_err(dev, "Error: negative/zero capture volume resolution\n");
1231		return -EINVAL;
1232	}
1233
1234	if ((opts->p_volume_max - opts->p_volume_min) % opts->p_volume_res) {
1235		dev_err(dev, "Error: incorrect playback volume resolution\n");
1236		return -EINVAL;
1237	} else if ((opts->c_volume_max - opts->c_volume_min) % opts->c_volume_res) {
1238		dev_err(dev, "Error: incorrect capture volume resolution\n");
1239		return -EINVAL;
1240	}
1241
1242	return 0;
1243}
1244
1245/* audio function driver setup/binding */
1246static int f_audio_bind(struct usb_configuration *c, struct usb_function *f)
1247{
1248	struct usb_composite_dev	*cdev = c->cdev;
1249	struct usb_gadget		*gadget = cdev->gadget;
1250	struct device			*dev = &gadget->dev;
1251	struct f_uac1			*uac1 = func_to_uac1(f);
1252	struct g_audio			*audio = func_to_g_audio(f);
1253	struct f_uac1_opts		*audio_opts;
1254	struct usb_ep			*ep = NULL;
1255	struct usb_string		*us;
1256	int				ba_iface_id;
1257	int				status;
1258	int				idx, i;
1259
1260	status = f_audio_validate_opts(audio, dev);
1261	if (status)
1262		return status;
1263
1264	audio_opts = container_of(f->fi, struct f_uac1_opts, func_inst);
1265
1266	strings_uac1[STR_AC_IF].s = audio_opts->function_name;
1267
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1268	us = usb_gstrings_attach(cdev, uac1_strings, ARRAY_SIZE(strings_uac1));
1269	if (IS_ERR(us))
1270		return PTR_ERR(us);
1271
1272	ac_header_desc = build_ac_header_desc(audio_opts);
1273	if (!ac_header_desc)
1274		return -ENOMEM;
1275
1276	if (FUOUT_EN(audio_opts)) {
1277		out_feature_unit_desc = build_fu_desc(audio_opts->c_chmask);
1278		if (!out_feature_unit_desc) {
1279			status = -ENOMEM;
1280			goto fail;
1281		}
1282	}
1283	if (FUIN_EN(audio_opts)) {
1284		in_feature_unit_desc = build_fu_desc(audio_opts->p_chmask);
1285		if (!in_feature_unit_desc) {
1286			status = -ENOMEM;
1287			goto err_free_fu;
1288		}
1289	}
1290
1291	ac_interface_desc.iInterface = us[STR_AC_IF].id;
1292	usb_out_it_desc.iTerminal = us[STR_USB_OUT_IT].id;
1293	usb_out_it_desc.iChannelNames = us[STR_USB_OUT_IT_CH_NAMES].id;
1294	io_out_ot_desc.iTerminal = us[STR_IO_OUT_OT].id;
1295	as_out_interface_alt_0_desc.iInterface = us[STR_AS_OUT_IF_ALT0].id;
1296	as_out_interface_alt_1_desc.iInterface = us[STR_AS_OUT_IF_ALT1].id;
1297	io_in_it_desc.iTerminal = us[STR_IO_IN_IT].id;
1298	io_in_it_desc.iChannelNames = us[STR_IO_IN_IT_CH_NAMES].id;
1299	usb_in_ot_desc.iTerminal = us[STR_USB_IN_OT].id;
1300	as_in_interface_alt_0_desc.iInterface = us[STR_AS_IN_IF_ALT0].id;
1301	as_in_interface_alt_1_desc.iInterface = us[STR_AS_IN_IF_ALT1].id;
1302
1303	if (FUOUT_EN(audio_opts)) {
1304		u8 *i_feature;
1305
1306		i_feature = (u8 *)out_feature_unit_desc +
1307					out_feature_unit_desc->bLength - 1;
1308		*i_feature = us[STR_FU_OUT].id;
1309	}
1310	if (FUIN_EN(audio_opts)) {
1311		u8 *i_feature;
1312
1313		i_feature = (u8 *)in_feature_unit_desc +
1314					in_feature_unit_desc->bLength - 1;
1315		*i_feature = us[STR_FU_IN].id;
1316	}
1317
1318	/* Set channel numbers */
1319	usb_out_it_desc.bNrChannels = num_channels(audio_opts->c_chmask);
1320	usb_out_it_desc.wChannelConfig = cpu_to_le16(audio_opts->c_chmask);
1321	as_out_type_i_desc.bNrChannels = num_channels(audio_opts->c_chmask);
1322	as_out_type_i_desc.bSubframeSize = audio_opts->c_ssize;
1323	as_out_type_i_desc.bBitResolution = audio_opts->c_ssize * 8;
1324	io_in_it_desc.bNrChannels = num_channels(audio_opts->p_chmask);
1325	io_in_it_desc.wChannelConfig = cpu_to_le16(audio_opts->p_chmask);
1326	as_in_type_i_desc.bNrChannels = num_channels(audio_opts->p_chmask);
1327	as_in_type_i_desc.bSubframeSize = audio_opts->p_ssize;
1328	as_in_type_i_desc.bBitResolution = audio_opts->p_ssize * 8;
1329
1330	if (FUOUT_EN(audio_opts)) {
1331		__le16 *bma = (__le16 *)&out_feature_unit_desc->bmaControls[0];
1332		u32 control = 0;
1333
1334		if (audio_opts->c_mute_present)
1335			control |= UAC_FU_MUTE;
1336		if (audio_opts->c_volume_present)
1337			control |= UAC_FU_VOLUME;
1338		*bma = cpu_to_le16(control);
1339	}
1340	if (FUIN_EN(audio_opts)) {
1341		__le16 *bma = (__le16 *)&in_feature_unit_desc->bmaControls[0];
1342		u32 control = 0;
1343
1344		if (audio_opts->p_mute_present)
1345			control |= UAC_FU_MUTE;
1346		if (audio_opts->p_volume_present)
1347			control |= UAC_FU_VOLUME;
1348		*bma = cpu_to_le16(control);
1349	}
1350
1351	/* Set sample rates */
1352	for (i = 0, idx = 0; i < UAC_MAX_RATES; i++) {
1353		if (audio_opts->c_srates[i] == 0)
1354			break;
1355		memcpy(as_out_type_i_desc.tSamFreq[idx++],
1356				&audio_opts->c_srates[i], 3);
1357	}
1358	as_out_type_i_desc.bLength = UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(idx);
1359	as_out_type_i_desc.bSamFreqType = idx;
1360
1361	for (i = 0, idx = 0; i < UAC_MAX_RATES; i++) {
1362		if (audio_opts->p_srates[i] == 0)
1363			break;
1364		memcpy(as_in_type_i_desc.tSamFreq[idx++],
1365				&audio_opts->p_srates[i], 3);
1366	}
1367	as_in_type_i_desc.bLength = UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(idx);
1368	as_in_type_i_desc.bSamFreqType = idx;
1369	uac1->p_srate = audio_opts->p_srates[0];
1370	uac1->c_srate = audio_opts->c_srates[0];
1371
1372	/* allocate instance-specific interface IDs, and patch descriptors */
1373	status = usb_interface_id(c, f);
1374	if (status < 0)
1375		goto err_free_fu;
1376	ac_interface_desc.bInterfaceNumber = status;
1377	uac1->ac_intf = status;
1378	uac1->ac_alt = 0;
1379
1380	ba_iface_id = 0;
1381
1382	if (EPOUT_EN(audio_opts)) {
1383		status = usb_interface_id(c, f);
1384		if (status < 0)
1385			goto err_free_fu;
1386		as_out_interface_alt_0_desc.bInterfaceNumber = status;
1387		as_out_interface_alt_1_desc.bInterfaceNumber = status;
1388		ac_header_desc->baInterfaceNr[ba_iface_id++] = status;
1389		uac1->as_out_intf = status;
1390		uac1->as_out_alt = 0;
1391	}
1392
1393	if (EPIN_EN(audio_opts)) {
1394		status = usb_interface_id(c, f);
1395		if (status < 0)
1396			goto err_free_fu;
1397		as_in_interface_alt_0_desc.bInterfaceNumber = status;
1398		as_in_interface_alt_1_desc.bInterfaceNumber = status;
1399		ac_header_desc->baInterfaceNr[ba_iface_id++] = status;
1400		uac1->as_in_intf = status;
1401		uac1->as_in_alt = 0;
1402	}
1403
1404	audio->gadget = gadget;
1405
1406	status = -ENODEV;
1407
1408	ac_interface_desc.bNumEndpoints = 0;
1409
1410	/* allocate AC interrupt endpoint */
1411	if (FUOUT_EN(audio_opts) || FUIN_EN(audio_opts)) {
1412		ep = usb_ep_autoconfig(cdev->gadget, &ac_int_ep_desc);
1413		if (!ep)
1414			goto err_free_fu;
1415		uac1->int_ep = ep;
1416		uac1->int_ep->desc = &ac_int_ep_desc;
1417
1418		ac_interface_desc.bNumEndpoints = 1;
1419	}
1420
1421	/* allocate instance-specific endpoints */
1422	if (EPOUT_EN(audio_opts)) {
1423		ep = usb_ep_autoconfig(cdev->gadget, &as_out_ep_desc);
1424		if (!ep)
1425			goto err_free_fu;
1426		ss_as_out_ep_desc.bEndpointAddress = as_out_ep_desc.bEndpointAddress;
1427		audio->out_ep = ep;
1428		audio->out_ep->desc = &as_out_ep_desc;
1429	}
1430
1431	if (EPIN_EN(audio_opts)) {
1432		ep = usb_ep_autoconfig(cdev->gadget, &as_in_ep_desc);
1433		if (!ep)
1434			goto err_free_fu;
1435		ss_as_in_ep_desc.bEndpointAddress = as_in_ep_desc.bEndpointAddress;
1436		audio->in_ep = ep;
1437		audio->in_ep->desc = &as_in_ep_desc;
1438	}
1439
1440	setup_descriptor(audio_opts);
1441
1442	/* copy descriptors, and track endpoint copies */
1443	status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, f_audio_ss_desc,
1444					f_audio_ss_desc);
1445	if (status)
1446		goto err_free_fu;
1447
1448	audio->out_ep_maxpsize = le16_to_cpu(as_out_ep_desc.wMaxPacketSize);
1449	audio->in_ep_maxpsize = le16_to_cpu(as_in_ep_desc.wMaxPacketSize);
1450	audio->params.c_chmask = audio_opts->c_chmask;
1451	memcpy(audio->params.c_srates, audio_opts->c_srates,
1452			sizeof(audio->params.c_srates));
1453	audio->params.c_ssize = audio_opts->c_ssize;
1454	if (FUIN_EN(audio_opts)) {
1455		audio->params.p_fu.id = USB_IN_FU_ID;
1456		audio->params.p_fu.mute_present = audio_opts->p_mute_present;
1457		audio->params.p_fu.volume_present =
1458				audio_opts->p_volume_present;
1459		audio->params.p_fu.volume_min = audio_opts->p_volume_min;
1460		audio->params.p_fu.volume_max = audio_opts->p_volume_max;
1461		audio->params.p_fu.volume_res = audio_opts->p_volume_res;
1462	}
1463	audio->params.p_chmask = audio_opts->p_chmask;
1464	memcpy(audio->params.p_srates, audio_opts->p_srates,
1465			sizeof(audio->params.p_srates));
1466	audio->params.p_ssize = audio_opts->p_ssize;
1467	if (FUOUT_EN(audio_opts)) {
1468		audio->params.c_fu.id = USB_OUT_FU_ID;
1469		audio->params.c_fu.mute_present = audio_opts->c_mute_present;
1470		audio->params.c_fu.volume_present =
1471				audio_opts->c_volume_present;
1472		audio->params.c_fu.volume_min = audio_opts->c_volume_min;
1473		audio->params.c_fu.volume_max = audio_opts->c_volume_max;
1474		audio->params.c_fu.volume_res = audio_opts->c_volume_res;
1475	}
1476	audio->params.req_number = audio_opts->req_number;
1477	audio->params.fb_max = FBACK_FAST_MAX;
1478	if (FUOUT_EN(audio_opts) || FUIN_EN(audio_opts))
1479		audio->notify = audio_notify;
1480
1481	status = g_audio_setup(audio, "UAC1_PCM", "UAC1_Gadget");
1482	if (status)
1483		goto err_card_register;
1484
1485	return 0;
1486
1487err_card_register:
1488	usb_free_all_descriptors(f);
1489err_free_fu:
1490	kfree(out_feature_unit_desc);
1491	out_feature_unit_desc = NULL;
1492	kfree(in_feature_unit_desc);
1493	in_feature_unit_desc = NULL;
1494fail:
1495	kfree(ac_header_desc);
1496	ac_header_desc = NULL;
1497	return status;
1498}
1499
1500/*-------------------------------------------------------------------------*/
1501
1502static inline struct f_uac1_opts *to_f_uac1_opts(struct config_item *item)
1503{
1504	return container_of(to_config_group(item), struct f_uac1_opts,
1505			    func_inst.group);
1506}
1507
1508static void f_uac1_attr_release(struct config_item *item)
1509{
1510	struct f_uac1_opts *opts = to_f_uac1_opts(item);
1511
1512	usb_put_function_instance(&opts->func_inst);
1513}
1514
1515static struct configfs_item_operations f_uac1_item_ops = {
1516	.release	= f_uac1_attr_release,
1517};
1518
1519#define uac1_kstrtou32			kstrtou32
1520#define uac1_kstrtos16			kstrtos16
1521#define uac1_kstrtobool(s, base, res)	kstrtobool((s), (res))
1522
1523static const char *u32_fmt = "%u\n";
1524static const char *s16_fmt = "%hd\n";
1525static const char *bool_fmt = "%u\n";
1526
1527#define UAC1_ATTRIBUTE(type, name)					\
1528static ssize_t f_uac1_opts_##name##_show(				\
1529					  struct config_item *item,	\
1530					  char *page)			\
1531{									\
1532	struct f_uac1_opts *opts = to_f_uac1_opts(item);		\
1533	int result;							\
1534									\
1535	mutex_lock(&opts->lock);					\
1536	result = sprintf(page, type##_fmt, opts->name);			\
1537	mutex_unlock(&opts->lock);					\
1538									\
1539	return result;							\
1540}									\
1541									\
1542static ssize_t f_uac1_opts_##name##_store(				\
1543					  struct config_item *item,	\
1544					  const char *page, size_t len)	\
1545{									\
1546	struct f_uac1_opts *opts = to_f_uac1_opts(item);		\
1547	int ret;							\
1548	type num;							\
1549									\
1550	mutex_lock(&opts->lock);					\
1551	if (opts->refcnt) {						\
1552		ret = -EBUSY;						\
1553		goto end;						\
1554	}								\
1555									\
1556	ret = uac1_kstrto##type(page, 0, &num);				\
1557	if (ret)							\
1558		goto end;						\
1559									\
1560	opts->name = num;						\
1561	ret = len;							\
1562									\
1563end:									\
1564	mutex_unlock(&opts->lock);					\
1565	return ret;							\
1566}									\
1567									\
1568CONFIGFS_ATTR(f_uac1_opts_, name)
1569
1570#define UAC1_RATE_ATTRIBUTE(name)					\
1571static ssize_t f_uac1_opts_##name##_show(struct config_item *item,	\
1572					 char *page)			\
1573{									\
1574	struct f_uac1_opts *opts = to_f_uac1_opts(item);		\
1575	int result = 0;							\
1576	int i;								\
1577									\
1578	mutex_lock(&opts->lock);					\
1579	page[0] = '\0';							\
1580	for (i = 0; i < UAC_MAX_RATES; i++) {				\
1581		if (opts->name##s[i] == 0)				\
1582			break;						\
1583		result += sprintf(page + strlen(page), "%u,",		\
1584				opts->name##s[i]);			\
1585	}								\
1586	if (strlen(page) > 0)						\
1587		page[strlen(page) - 1] = '\n';				\
1588	mutex_unlock(&opts->lock);					\
1589									\
1590	return result;							\
1591}									\
1592									\
1593static ssize_t f_uac1_opts_##name##_store(struct config_item *item,	\
1594					  const char *page, size_t len)	\
1595{									\
1596	struct f_uac1_opts *opts = to_f_uac1_opts(item);		\
1597	char *split_page = NULL;					\
1598	int ret = -EINVAL;						\
1599	char *token;							\
1600	u32 num;							\
1601	int i;								\
1602									\
1603	mutex_lock(&opts->lock);					\
1604	if (opts->refcnt) {						\
1605		ret = -EBUSY;						\
1606		goto end;						\
1607	}								\
1608									\
1609	i = 0;								\
1610	memset(opts->name##s, 0x00, sizeof(opts->name##s));		\
1611	split_page = kstrdup(page, GFP_KERNEL);				\
1612	while ((token = strsep(&split_page, ",")) != NULL) {		\
1613		ret = kstrtou32(token, 0, &num);			\
1614		if (ret)						\
1615			goto end;					\
1616									\
1617		opts->name##s[i++] = num;				\
1618		ret = len;						\
1619	};								\
1620									\
1621end:									\
1622	kfree(split_page);						\
1623	mutex_unlock(&opts->lock);					\
1624	return ret;							\
1625}									\
1626									\
1627CONFIGFS_ATTR(f_uac1_opts_, name)
1628
1629#define UAC1_ATTRIBUTE_STRING(name)					\
1630static ssize_t f_uac1_opts_##name##_show(struct config_item *item,	\
1631					 char *page)			\
1632{									\
1633	struct f_uac1_opts *opts = to_f_uac1_opts(item);		\
1634	int result;							\
1635									\
1636	mutex_lock(&opts->lock);					\
1637	result = scnprintf(page, sizeof(opts->name), "%s", opts->name);	\
1638	mutex_unlock(&opts->lock);					\
1639									\
1640	return result;							\
1641}									\
1642									\
1643static ssize_t f_uac1_opts_##name##_store(struct config_item *item,	\
1644					  const char *page, size_t len)	\
1645{									\
1646	struct f_uac1_opts *opts = to_f_uac1_opts(item);		\
1647	int ret = 0;							\
1648									\
1649	mutex_lock(&opts->lock);					\
1650	if (opts->refcnt) {						\
1651		ret = -EBUSY;						\
1652		goto end;						\
1653	}								\
1654									\
1655	ret = scnprintf(opts->name, min(sizeof(opts->name), len),	\
1656			"%s", page);					\
1657									\
1658end:									\
1659	mutex_unlock(&opts->lock);					\
1660	return ret;							\
1661}									\
1662									\
1663CONFIGFS_ATTR(f_uac1_opts_, name)
1664
1665UAC1_ATTRIBUTE(u32, c_chmask);
1666UAC1_RATE_ATTRIBUTE(c_srate);
1667UAC1_ATTRIBUTE(u32, c_ssize);
1668UAC1_ATTRIBUTE(u32, p_chmask);
1669UAC1_RATE_ATTRIBUTE(p_srate);
1670UAC1_ATTRIBUTE(u32, p_ssize);
1671UAC1_ATTRIBUTE(u32, req_number);
1672
1673UAC1_ATTRIBUTE(bool, p_mute_present);
1674UAC1_ATTRIBUTE(bool, p_volume_present);
1675UAC1_ATTRIBUTE(s16, p_volume_min);
1676UAC1_ATTRIBUTE(s16, p_volume_max);
1677UAC1_ATTRIBUTE(s16, p_volume_res);
1678
1679UAC1_ATTRIBUTE(bool, c_mute_present);
1680UAC1_ATTRIBUTE(bool, c_volume_present);
1681UAC1_ATTRIBUTE(s16, c_volume_min);
1682UAC1_ATTRIBUTE(s16, c_volume_max);
1683UAC1_ATTRIBUTE(s16, c_volume_res);
 
1684UAC1_ATTRIBUTE_STRING(function_name);
1685
 
 
 
 
 
 
 
 
 
 
1686static struct configfs_attribute *f_uac1_attrs[] = {
1687	&f_uac1_opts_attr_c_chmask,
1688	&f_uac1_opts_attr_c_srate,
1689	&f_uac1_opts_attr_c_ssize,
1690	&f_uac1_opts_attr_p_chmask,
1691	&f_uac1_opts_attr_p_srate,
1692	&f_uac1_opts_attr_p_ssize,
1693	&f_uac1_opts_attr_req_number,
1694
1695	&f_uac1_opts_attr_p_mute_present,
1696	&f_uac1_opts_attr_p_volume_present,
1697	&f_uac1_opts_attr_p_volume_min,
1698	&f_uac1_opts_attr_p_volume_max,
1699	&f_uac1_opts_attr_p_volume_res,
1700
1701	&f_uac1_opts_attr_c_mute_present,
1702	&f_uac1_opts_attr_c_volume_present,
1703	&f_uac1_opts_attr_c_volume_min,
1704	&f_uac1_opts_attr_c_volume_max,
1705	&f_uac1_opts_attr_c_volume_res,
1706
1707	&f_uac1_opts_attr_function_name,
1708
 
 
 
 
 
 
 
 
 
 
1709	NULL,
1710};
1711
1712static const struct config_item_type f_uac1_func_type = {
1713	.ct_item_ops	= &f_uac1_item_ops,
1714	.ct_attrs	= f_uac1_attrs,
1715	.ct_owner	= THIS_MODULE,
1716};
1717
1718static void f_audio_free_inst(struct usb_function_instance *f)
1719{
1720	struct f_uac1_opts *opts;
1721
1722	opts = container_of(f, struct f_uac1_opts, func_inst);
1723	kfree(opts);
1724}
1725
1726static struct usb_function_instance *f_audio_alloc_inst(void)
1727{
1728	struct f_uac1_opts *opts;
1729
1730	opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1731	if (!opts)
1732		return ERR_PTR(-ENOMEM);
1733
1734	mutex_init(&opts->lock);
1735	opts->func_inst.free_func_inst = f_audio_free_inst;
1736
1737	config_group_init_type_name(&opts->func_inst.group, "",
1738				    &f_uac1_func_type);
1739
1740	opts->c_chmask = UAC1_DEF_CCHMASK;
1741	opts->c_srates[0] = UAC1_DEF_CSRATE;
1742	opts->c_ssize = UAC1_DEF_CSSIZE;
1743	opts->p_chmask = UAC1_DEF_PCHMASK;
1744	opts->p_srates[0] = UAC1_DEF_PSRATE;
1745	opts->p_ssize = UAC1_DEF_PSSIZE;
1746
1747	opts->p_mute_present = UAC1_DEF_MUTE_PRESENT;
1748	opts->p_volume_present = UAC1_DEF_VOLUME_PRESENT;
1749	opts->p_volume_min = UAC1_DEF_MIN_DB;
1750	opts->p_volume_max = UAC1_DEF_MAX_DB;
1751	opts->p_volume_res = UAC1_DEF_RES_DB;
1752
1753	opts->c_mute_present = UAC1_DEF_MUTE_PRESENT;
1754	opts->c_volume_present = UAC1_DEF_VOLUME_PRESENT;
1755	opts->c_volume_min = UAC1_DEF_MIN_DB;
1756	opts->c_volume_max = UAC1_DEF_MAX_DB;
1757	opts->c_volume_res = UAC1_DEF_RES_DB;
1758
1759	opts->req_number = UAC1_DEF_REQ_NUM;
1760
1761	scnprintf(opts->function_name, sizeof(opts->function_name), "AC Interface");
1762
 
 
 
 
 
 
 
 
 
 
1763	return &opts->func_inst;
1764}
1765
1766static void f_audio_free(struct usb_function *f)
1767{
1768	struct g_audio *audio;
1769	struct f_uac1_opts *opts;
1770
1771	audio = func_to_g_audio(f);
1772	opts = container_of(f->fi, struct f_uac1_opts, func_inst);
1773	kfree(audio);
1774	mutex_lock(&opts->lock);
1775	--opts->refcnt;
1776	mutex_unlock(&opts->lock);
1777}
1778
1779static void f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
1780{
1781	struct g_audio *audio = func_to_g_audio(f);
1782
1783	g_audio_cleanup(audio);
1784	usb_free_all_descriptors(f);
1785
1786	kfree(out_feature_unit_desc);
1787	out_feature_unit_desc = NULL;
1788	kfree(in_feature_unit_desc);
1789	in_feature_unit_desc = NULL;
1790
1791	kfree(ac_header_desc);
1792	ac_header_desc = NULL;
1793
1794	audio->gadget = NULL;
1795}
1796
1797static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
1798{
1799	struct f_uac1 *uac1;
1800	struct f_uac1_opts *opts;
1801
1802	/* allocate and initialize one new instance */
1803	uac1 = kzalloc(sizeof(*uac1), GFP_KERNEL);
1804	if (!uac1)
1805		return ERR_PTR(-ENOMEM);
1806
1807	opts = container_of(fi, struct f_uac1_opts, func_inst);
1808	mutex_lock(&opts->lock);
1809	++opts->refcnt;
1810	mutex_unlock(&opts->lock);
1811
1812	uac1->g_audio.func.name = "uac1_func";
1813	uac1->g_audio.func.bind = f_audio_bind;
1814	uac1->g_audio.func.unbind = f_audio_unbind;
1815	uac1->g_audio.func.set_alt = f_audio_set_alt;
1816	uac1->g_audio.func.get_alt = f_audio_get_alt;
1817	uac1->g_audio.func.setup = f_audio_setup;
1818	uac1->g_audio.func.disable = f_audio_disable;
1819	uac1->g_audio.func.suspend = f_audio_suspend;
1820	uac1->g_audio.func.free_func = f_audio_free;
1821
1822	return &uac1->g_audio.func;
1823}
1824
1825DECLARE_USB_FUNCTION_INIT(uac1, f_audio_alloc_inst, f_audio_alloc);
 
1826MODULE_LICENSE("GPL");
1827MODULE_AUTHOR("Ruslan Bilovol");