1/*
2 * Gadget Function Driver for USB audio source device
3 *
4 * Copyright (C) 2012 Google, Inc.
5 *
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 * GNU General Public License for more details.
14 *
15 */
16
17#include <linux/device.h>
18#include <linux/usb/audio.h>
19#include <linux/wait.h>
20#include <sound/core.h>
21#include <sound/initval.h>
22#include <sound/pcm.h>
23
24#include <linux/usb.h>
25#include <linux/usb_usual.h>
26#include <linux/usb/ch9.h>
27#include <linux/configfs.h>
28#include <linux/usb/composite.h>
29#include <linux/module.h>
30#include <linux/moduleparam.h>
31#define SAMPLE_RATE 44100
32#define FRAMES_PER_MSEC (SAMPLE_RATE / 1000)
33
34#define IN_EP_MAX_PACKET_SIZE 256
35
36/* Number of requests to allocate */
37#define IN_EP_REQ_COUNT 4
38
39#define AUDIO_AC_INTERFACE	0
40#define AUDIO_AS_INTERFACE	1
41#define AUDIO_NUM_INTERFACES	2
42#define MAX_INST_NAME_LEN     40
43
44/* B.3.1  Standard AC Interface Descriptor */
45static struct usb_interface_descriptor ac_interface_desc = {
46	.bLength =		USB_DT_INTERFACE_SIZE,
47	.bDescriptorType =	USB_DT_INTERFACE,
48	.bNumEndpoints =	0,
49	.bInterfaceClass =	USB_CLASS_AUDIO,
50	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOCONTROL,
51};
52
53DECLARE_UAC_AC_HEADER_DESCRIPTOR(2);
54
55#define UAC_DT_AC_HEADER_LENGTH	UAC_DT_AC_HEADER_SIZE(AUDIO_NUM_INTERFACES)
56/* 1 input terminal, 1 output terminal and 1 feature unit */
57#define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH \
58	+ UAC_DT_INPUT_TERMINAL_SIZE + UAC_DT_OUTPUT_TERMINAL_SIZE \
59	+ UAC_DT_FEATURE_UNIT_SIZE(0))
60/* B.3.2  Class-Specific AC Interface Descriptor */
61static struct uac1_ac_header_descriptor_2 ac_header_desc = {
62	.bLength =		UAC_DT_AC_HEADER_LENGTH,
63	.bDescriptorType =	USB_DT_CS_INTERFACE,
64	.bDescriptorSubtype =	UAC_HEADER,
65	.bcdADC =		__constant_cpu_to_le16(0x0100),
66	.wTotalLength =		__constant_cpu_to_le16(UAC_DT_TOTAL_LENGTH),
67	.bInCollection =	AUDIO_NUM_INTERFACES,
68	.baInterfaceNr = {
69		[0] =		AUDIO_AC_INTERFACE,
70		[1] =		AUDIO_AS_INTERFACE,
71	}
72};
73
74#define INPUT_TERMINAL_ID	1
75static struct uac_input_terminal_descriptor input_terminal_desc = {
76	.bLength =		UAC_DT_INPUT_TERMINAL_SIZE,
77	.bDescriptorType =	USB_DT_CS_INTERFACE,
78	.bDescriptorSubtype =	UAC_INPUT_TERMINAL,
79	.bTerminalID =		INPUT_TERMINAL_ID,
80	.wTerminalType =	UAC_INPUT_TERMINAL_MICROPHONE,
81	.bAssocTerminal =	0,
82	.wChannelConfig =	0x3,
83};
84
85DECLARE_UAC_FEATURE_UNIT_DESCRIPTOR(0);
86
87#define FEATURE_UNIT_ID		2
88static struct uac_feature_unit_descriptor_0 feature_unit_desc = {
89	.bLength		= UAC_DT_FEATURE_UNIT_SIZE(0),
90	.bDescriptorType	= USB_DT_CS_INTERFACE,
91	.bDescriptorSubtype	= UAC_FEATURE_UNIT,
92	.bUnitID		= FEATURE_UNIT_ID,
93	.bSourceID		= INPUT_TERMINAL_ID,
94	.bControlSize		= 2,
95};
96
97#define OUTPUT_TERMINAL_ID	3
98static struct uac1_output_terminal_descriptor output_terminal_desc = {
99	.bLength		= UAC_DT_OUTPUT_TERMINAL_SIZE,
100	.bDescriptorType	= USB_DT_CS_INTERFACE,
101	.bDescriptorSubtype	= UAC_OUTPUT_TERMINAL,
102	.bTerminalID		= OUTPUT_TERMINAL_ID,
103	.wTerminalType		= UAC_TERMINAL_STREAMING,
104	.bAssocTerminal		= FEATURE_UNIT_ID,
105	.bSourceID		= FEATURE_UNIT_ID,
106};
107
108/* B.4.1  Standard AS Interface Descriptor */
109static struct usb_interface_descriptor as_interface_alt_0_desc = {
110	.bLength =		USB_DT_INTERFACE_SIZE,
111	.bDescriptorType =	USB_DT_INTERFACE,
112	.bAlternateSetting =	0,
113	.bNumEndpoints =	0,
114	.bInterfaceClass =	USB_CLASS_AUDIO,
115	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
116};
117
118static struct usb_interface_descriptor as_interface_alt_1_desc = {
119	.bLength =		USB_DT_INTERFACE_SIZE,
120	.bDescriptorType =	USB_DT_INTERFACE,
121	.bAlternateSetting =	1,
122	.bNumEndpoints =	1,
123	.bInterfaceClass =	USB_CLASS_AUDIO,
124	.bInterfaceSubClass =	USB_SUBCLASS_AUDIOSTREAMING,
125};
126
127/* B.4.2  Class-Specific AS Interface Descriptor */
128static struct uac1_as_header_descriptor as_header_desc = {
129	.bLength =		UAC_DT_AS_HEADER_SIZE,
130	.bDescriptorType =	USB_DT_CS_INTERFACE,
131	.bDescriptorSubtype =	UAC_AS_GENERAL,
132	.bTerminalLink =	INPUT_TERMINAL_ID,
133	.bDelay =		1,
134	.wFormatTag =		UAC_FORMAT_TYPE_I_PCM,
135};
136
137DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(1);
138
139static struct uac_format_type_i_discrete_descriptor_1 as_type_i_desc = {
140	.bLength =		UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
141	.bDescriptorType =	USB_DT_CS_INTERFACE,
142	.bDescriptorSubtype =	UAC_FORMAT_TYPE,
143	.bFormatType =		UAC_FORMAT_TYPE_I,
144	.bSubframeSize =	2,
145	.bBitResolution =	16,
146	.bSamFreqType =		1,
147};
148
149/* Standard ISO IN Endpoint Descriptor for highspeed */
150static struct usb_endpoint_descriptor hs_as_in_ep_desc  = {
151	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
152	.bDescriptorType =	USB_DT_ENDPOINT,
153	.bEndpointAddress =	USB_DIR_IN,
154	.bmAttributes =		USB_ENDPOINT_SYNC_SYNC
155				| USB_ENDPOINT_XFER_ISOC,
156	.wMaxPacketSize =	__constant_cpu_to_le16(IN_EP_MAX_PACKET_SIZE),
157	.bInterval =		4, /* poll 1 per millisecond */
158};
159
160/* Standard ISO IN Endpoint Descriptor for highspeed */
161static struct usb_endpoint_descriptor fs_as_in_ep_desc  = {
162	.bLength =		USB_DT_ENDPOINT_AUDIO_SIZE,
163	.bDescriptorType =	USB_DT_ENDPOINT,
164	.bEndpointAddress =	USB_DIR_IN,
165	.bmAttributes =		USB_ENDPOINT_SYNC_SYNC
166				| USB_ENDPOINT_XFER_ISOC,
167	.wMaxPacketSize =	__constant_cpu_to_le16(IN_EP_MAX_PACKET_SIZE),
168	.bInterval =		1, /* poll 1 per millisecond */
169};
170
171/* Class-specific AS ISO OUT Endpoint Descriptor */
172static struct uac_iso_endpoint_descriptor as_iso_in_desc = {
173	.bLength =		UAC_ISO_ENDPOINT_DESC_SIZE,
174	.bDescriptorType =	USB_DT_CS_ENDPOINT,
175	.bDescriptorSubtype =	UAC_EP_GENERAL,
176	.bmAttributes =		1,
177	.bLockDelayUnits =	1,
178	.wLockDelay =		__constant_cpu_to_le16(1),
179};
180
181static struct usb_descriptor_header *hs_audio_desc[] = {
182	(struct usb_descriptor_header *)&ac_interface_desc,
183	(struct usb_descriptor_header *)&ac_header_desc,
184
185	(struct usb_descriptor_header *)&input_terminal_desc,
186	(struct usb_descriptor_header *)&output_terminal_desc,
187	(struct usb_descriptor_header *)&feature_unit_desc,
188
189	(struct usb_descriptor_header *)&as_interface_alt_0_desc,
190	(struct usb_descriptor_header *)&as_interface_alt_1_desc,
191	(struct usb_descriptor_header *)&as_header_desc,
192
193	(struct usb_descriptor_header *)&as_type_i_desc,
194
195	(struct usb_descriptor_header *)&hs_as_in_ep_desc,
196	(struct usb_descriptor_header *)&as_iso_in_desc,
197	NULL,
198};
199
200static struct usb_descriptor_header *fs_audio_desc[] = {
201	(struct usb_descriptor_header *)&ac_interface_desc,
202	(struct usb_descriptor_header *)&ac_header_desc,
203
204	(struct usb_descriptor_header *)&input_terminal_desc,
205	(struct usb_descriptor_header *)&output_terminal_desc,
206	(struct usb_descriptor_header *)&feature_unit_desc,
207
208	(struct usb_descriptor_header *)&as_interface_alt_0_desc,
209	(struct usb_descriptor_header *)&as_interface_alt_1_desc,
210	(struct usb_descriptor_header *)&as_header_desc,
211
212	(struct usb_descriptor_header *)&as_type_i_desc,
213
214	(struct usb_descriptor_header *)&fs_as_in_ep_desc,
215	(struct usb_descriptor_header *)&as_iso_in_desc,
216	NULL,
217};
218
219static struct snd_pcm_hardware audio_hw_info = {
220	.info =			SNDRV_PCM_INFO_MMAP |
221				SNDRV_PCM_INFO_MMAP_VALID |
222				SNDRV_PCM_INFO_BATCH |
223				SNDRV_PCM_INFO_INTERLEAVED |
224				SNDRV_PCM_INFO_BLOCK_TRANSFER,
225
226	.formats		= SNDRV_PCM_FMTBIT_S16_LE,
227	.channels_min		= 2,
228	.channels_max		= 2,
229	.rate_min		= SAMPLE_RATE,
230	.rate_max		= SAMPLE_RATE,
231
232	.buffer_bytes_max =	1024 * 1024,
233	.period_bytes_min =	64,
234	.period_bytes_max =	512 * 1024,
235	.periods_min =		2,
236	.periods_max =		1024,
237};
238
239/*-------------------------------------------------------------------------*/
240
241struct audio_source_config {
242	int	card;
243	int	device;
244};
245
246struct audio_dev {
247	struct usb_function		func;
248	struct snd_card			*card;
249	struct snd_pcm			*pcm;
250	struct snd_pcm_substream *substream;
251
252	struct list_head		idle_reqs;
253	struct usb_ep			*in_ep;
254
255	spinlock_t			lock;
256
257	/* beginning, end and current position in our buffer */
258	void				*buffer_start;
259	void				*buffer_end;
260	void				*buffer_pos;
261
262	/* byte size of a "period" */
263	unsigned int			period;
264	/* bytes sent since last call to snd_pcm_period_elapsed */
265	unsigned int			period_offset;
266	/* time we started playing */
267	ktime_t				start_time;
268	/* number of frames sent since start_time */
269	s64				frames_sent;
270	struct audio_source_config	*config;
271};
272
273static inline struct audio_dev *func_to_audio(struct usb_function *f)
274{
275	return container_of(f, struct audio_dev, func);
276}
277
278/*-------------------------------------------------------------------------*/
279
280struct audio_source_instance {
281	struct usb_function_instance func_inst;
282	const char *name;
283	struct audio_source_config *config;
284	struct device *audio_device;
285};
286
287static void audio_source_attr_release(struct config_item *item);
288
289static struct configfs_item_operations audio_source_item_ops = {
290	.release        = audio_source_attr_release,
291};
292
293static struct config_item_type audio_source_func_type = {
294	.ct_item_ops    = &audio_source_item_ops,
295	.ct_owner       = THIS_MODULE,
296};
297
298static ssize_t audio_source_pcm_show(struct device *dev,
299		struct device_attribute *attr, char *buf);
300
301static DEVICE_ATTR(pcm, S_IRUGO, audio_source_pcm_show, NULL);
302
303static struct device_attribute *audio_source_function_attributes[] = {
304	&dev_attr_pcm,
305	NULL
306};
307
308/*--------------------------------------------------------------------------*/
309
310static struct usb_request *audio_request_new(struct usb_ep *ep, int buffer_size)
311{
312	struct usb_request *req = usb_ep_alloc_request(ep, GFP_KERNEL);
313	if (!req)
314		return NULL;
315
316	req->buf = kmalloc(buffer_size, GFP_KERNEL);
317	if (!req->buf) {
318		usb_ep_free_request(ep, req);
319		return NULL;
320	}
321	req->length = buffer_size;
322	return req;
323}
324
325static void audio_request_free(struct usb_request *req, struct usb_ep *ep)
326{
327	if (req) {
328		kfree(req->buf);
329		usb_ep_free_request(ep, req);
330	}
331}
332
333static void audio_req_put(struct audio_dev *audio, struct usb_request *req)
334{
335	unsigned long flags;
336
337	spin_lock_irqsave(&audio->lock, flags);
338	list_add_tail(&req->list, &audio->idle_reqs);
339	spin_unlock_irqrestore(&audio->lock, flags);
340}
341
342static struct usb_request *audio_req_get(struct audio_dev *audio)
343{
344	unsigned long flags;
345	struct usb_request *req;
346
347	spin_lock_irqsave(&audio->lock, flags);
348	if (list_empty(&audio->idle_reqs)) {
349		req = 0;
350	} else {
351		req = list_first_entry(&audio->idle_reqs, struct usb_request,
352				list);
353		list_del(&req->list);
354	}
355	spin_unlock_irqrestore(&audio->lock, flags);
356	return req;
357}
358
359/* send the appropriate number of packets to match our bitrate */
360static void audio_send(struct audio_dev *audio)
361{
362	struct snd_pcm_runtime *runtime;
363	struct usb_request *req;
364	int length, length1, length2, ret;
365	s64 msecs;
366	s64 frames;
367	ktime_t now;
368
369	/* audio->substream will be null if we have been closed */
370	if (!audio->substream)
371		return;
372	/* audio->buffer_pos will be null if we have been stopped */
373	if (!audio->buffer_pos)
374		return;
375
376	runtime = audio->substream->runtime;
377
378	/* compute number of frames to send */
379	now = ktime_get();
380	msecs = ktime_to_ns(now) - ktime_to_ns(audio->start_time);
381	do_div(msecs, 1000000);
382	frames = msecs * SAMPLE_RATE;
383	do_div(frames, 1000);
384
385	/* Readjust our frames_sent if we fall too far behind.
386	 * If we get too far behind it is better to drop some frames than
387	 * to keep sending data too fast in an attempt to catch up.
388	 */
389	if (frames - audio->frames_sent > 10 * FRAMES_PER_MSEC)
390		audio->frames_sent = frames - FRAMES_PER_MSEC;
391
392	frames -= audio->frames_sent;
393
394	/* We need to send something to keep the pipeline going */
395	if (frames <= 0)
396		frames = FRAMES_PER_MSEC;
397
398	while (frames > 0) {
399		req = audio_req_get(audio);
400		if (!req)
401			break;
402
403		length = frames_to_bytes(runtime, frames);
404		if (length > IN_EP_MAX_PACKET_SIZE)
405			length = IN_EP_MAX_PACKET_SIZE;
406
407		if (audio->buffer_pos + length > audio->buffer_end)
408			length1 = audio->buffer_end - audio->buffer_pos;
409		else
410			length1 = length;
411		memcpy(req->buf, audio->buffer_pos, length1);
412		if (length1 < length) {
413			/* Wrap around and copy remaining length
414			 * at beginning of buffer.
415			 */
416			length2 = length - length1;
417			memcpy(req->buf + length1, audio->buffer_start,
418					length2);
419			audio->buffer_pos = audio->buffer_start + length2;
420		} else {
421			audio->buffer_pos += length1;
422			if (audio->buffer_pos >= audio->buffer_end)
423				audio->buffer_pos = audio->buffer_start;
424		}
425
426		req->length = length;
427		ret = usb_ep_queue(audio->in_ep, req, GFP_ATOMIC);
428		if (ret < 0) {
429			pr_err("usb_ep_queue failed ret: %d\n", ret);
430			audio_req_put(audio, req);
431			break;
432		}
433
434		frames -= bytes_to_frames(runtime, length);
435		audio->frames_sent += bytes_to_frames(runtime, length);
436	}
437}
438
439static void audio_control_complete(struct usb_ep *ep, struct usb_request *req)
440{
441	/* nothing to do here */
442}
443
444static void audio_data_complete(struct usb_ep *ep, struct usb_request *req)
445{
446	struct audio_dev *audio = req->context;
447
448	pr_debug("audio_data_complete req->status %d req->actual %d\n",
449		req->status, req->actual);
450
451	audio_req_put(audio, req);
452
453	if (!audio->buffer_start || req->status)
454		return;
455
456	audio->period_offset += req->actual;
457	if (audio->period_offset >= audio->period) {
458		snd_pcm_period_elapsed(audio->substream);
459		audio->period_offset = 0;
460	}
461	audio_send(audio);
462}
463
464static int audio_set_endpoint_req(struct usb_function *f,
465		const struct usb_ctrlrequest *ctrl)
466{
467	int value = -EOPNOTSUPP;
468	u16 ep = le16_to_cpu(ctrl->wIndex);
469	u16 len = le16_to_cpu(ctrl->wLength);
470	u16 w_value = le16_to_cpu(ctrl->wValue);
471
472	pr_debug("bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
473			ctrl->bRequest, w_value, len, ep);
474
475	switch (ctrl->bRequest) {
476	case UAC_SET_CUR:
477	case UAC_SET_MIN:
478	case UAC_SET_MAX:
479	case UAC_SET_RES:
480		value = len;
481		break;
482	default:
483		break;
484	}
485
486	return value;
487}
488
489static int audio_get_endpoint_req(struct usb_function *f,
490		const struct usb_ctrlrequest *ctrl)
491{
492	struct usb_composite_dev *cdev = f->config->cdev;
493	int value = -EOPNOTSUPP;
494	u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
495	u16 len = le16_to_cpu(ctrl->wLength);
496	u16 w_value = le16_to_cpu(ctrl->wValue);
497	u8 *buf = cdev->req->buf;
498
499	pr_debug("bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
500			ctrl->bRequest, w_value, len, ep);
501
502	if (w_value == UAC_EP_CS_ATTR_SAMPLE_RATE << 8) {
503		switch (ctrl->bRequest) {
504		case UAC_GET_CUR:
505		case UAC_GET_MIN:
506		case UAC_GET_MAX:
507		case UAC_GET_RES:
508			/* return our sample rate */
509			buf[0] = (u8)SAMPLE_RATE;
510			buf[1] = (u8)(SAMPLE_RATE >> 8);
511			buf[2] = (u8)(SAMPLE_RATE >> 16);
512			value = 3;
513			break;
514		default:
515			break;
516		}
517	}
518
519	return value;
520}
521
522static int
523audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
524{
525	struct usb_composite_dev *cdev = f->config->cdev;
526	struct usb_request *req = cdev->req;
527	int value = -EOPNOTSUPP;
528	u16 w_index = le16_to_cpu(ctrl->wIndex);
529	u16 w_value = le16_to_cpu(ctrl->wValue);
530	u16 w_length = le16_to_cpu(ctrl->wLength);
531
532	/* composite driver infrastructure handles everything; interface
533	 * activation uses set_alt().
534	 */
535	switch (ctrl->bRequestType) {
536	case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
537		value = audio_set_endpoint_req(f, ctrl);
538		break;
539
540	case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
541		value = audio_get_endpoint_req(f, ctrl);
542		break;
543	}
544
545	/* respond with data transfer or status phase? */
546	if (value >= 0) {
547		pr_debug("audio req%02x.%02x v%04x i%04x l%d\n",
548			ctrl->bRequestType, ctrl->bRequest,
549			w_value, w_index, w_length);
550		req->zero = 0;
551		req->length = value;
552		req->complete = audio_control_complete;
553		value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
554		if (value < 0)
555			pr_err("audio response on err %d\n", value);
556	}
557
558	/* device either stalls (value < 0) or reports success */
559	return value;
560}
561
562static int audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
563{
564	struct audio_dev *audio = func_to_audio(f);
565	struct usb_composite_dev *cdev = f->config->cdev;
566	int ret;
567
568	pr_debug("audio_set_alt intf %d, alt %d\n", intf, alt);
569
570	ret = config_ep_by_speed(cdev->gadget, f, audio->in_ep);
571	if (ret)
572		return ret;
573
574	usb_ep_enable(audio->in_ep);
575	return 0;
576}
577
578static void audio_disable(struct usb_function *f)
579{
580	struct audio_dev	*audio = func_to_audio(f);
581
582	pr_debug("audio_disable\n");
583	usb_ep_disable(audio->in_ep);
584}
585
586/*-------------------------------------------------------------------------*/
587
588static void audio_build_desc(struct audio_dev *audio)
589{
590	u8 *sam_freq;
591	int rate;
592
593	/* Set channel numbers */
594	input_terminal_desc.bNrChannels = 2;
595	as_type_i_desc.bNrChannels = 2;
596
597	/* Set sample rates */
598	rate = SAMPLE_RATE;
599	sam_freq = as_type_i_desc.tSamFreq[0];
600	memcpy(sam_freq, &rate, 3);
601}
602
603
604static int snd_card_setup(struct usb_configuration *c,
605	struct audio_source_config *config);
606static struct audio_source_instance *to_fi_audio_source(
607	const struct usb_function_instance *fi);
608
609
610/* audio function driver setup/binding */
611static int
612audio_bind(struct usb_configuration *c, struct usb_function *f)
613{
614	struct usb_composite_dev *cdev = c->cdev;
615	struct audio_dev *audio = func_to_audio(f);
616	int status;
617	struct usb_ep *ep;
618	struct usb_request *req;
619	int i;
620	int err;
621
622	if (IS_ENABLED(CONFIG_USB_CONFIGFS)) {
623		struct audio_source_instance *fi_audio =
624				to_fi_audio_source(f->fi);
625		struct audio_source_config *config =
626				fi_audio->config;
627
628		err = snd_card_setup(c, config);
629		if (err)
630			return err;
631	}
632
633	audio_build_desc(audio);
634
635	/* allocate instance-specific interface IDs, and patch descriptors */
636	status = usb_interface_id(c, f);
637	if (status < 0)
638		goto fail;
639	ac_interface_desc.bInterfaceNumber = status;
640
641	/* AUDIO_AC_INTERFACE */
642	ac_header_desc.baInterfaceNr[0] = status;
643
644	status = usb_interface_id(c, f);
645	if (status < 0)
646		goto fail;
647	as_interface_alt_0_desc.bInterfaceNumber = status;
648	as_interface_alt_1_desc.bInterfaceNumber = status;
649
650	/* AUDIO_AS_INTERFACE */
651	ac_header_desc.baInterfaceNr[1] = status;
652
653	status = -ENODEV;
654
655	/* allocate our endpoint */
656	ep = usb_ep_autoconfig(cdev->gadget, &fs_as_in_ep_desc);
657	if (!ep)
658		goto fail;
659	audio->in_ep = ep;
660	ep->driver_data = audio; /* claim */
661
662	if (gadget_is_dualspeed(c->cdev->gadget))
663		hs_as_in_ep_desc.bEndpointAddress =
664			fs_as_in_ep_desc.bEndpointAddress;
665
666	f->fs_descriptors = fs_audio_desc;
667	f->hs_descriptors = hs_audio_desc;
668
669	for (i = 0, status = 0; i < IN_EP_REQ_COUNT && status == 0; i++) {
670		req = audio_request_new(ep, IN_EP_MAX_PACKET_SIZE);
671		if (req) {
672			req->context = audio;
673			req->complete = audio_data_complete;
674			audio_req_put(audio, req);
675		} else
676			status = -ENOMEM;
677	}
678
679fail:
680	return status;
681}
682
683static void
684audio_unbind(struct usb_configuration *c, struct usb_function *f)
685{
686	struct audio_dev *audio = func_to_audio(f);
687	struct usb_request *req;
688
689	while ((req = audio_req_get(audio)))
690		audio_request_free(req, audio->in_ep);
691
692	snd_card_free_when_closed(audio->card);
693	audio->card = NULL;
694	audio->pcm = NULL;
695	audio->substream = NULL;
696	audio->in_ep = NULL;
697
698	if (IS_ENABLED(CONFIG_USB_CONFIGFS)) {
699		struct audio_source_instance *fi_audio =
700				to_fi_audio_source(f->fi);
701		struct audio_source_config *config =
702				fi_audio->config;
703
704		config->card = -1;
705		config->device = -1;
706	}
707}
708
709static void audio_pcm_playback_start(struct audio_dev *audio)
710{
711	audio->start_time = ktime_get();
712	audio->frames_sent = 0;
713	audio_send(audio);
714}
715
716static void audio_pcm_playback_stop(struct audio_dev *audio)
717{
718	unsigned long flags;
719
720	spin_lock_irqsave(&audio->lock, flags);
721	audio->buffer_start = 0;
722	audio->buffer_end = 0;
723	audio->buffer_pos = 0;
724	spin_unlock_irqrestore(&audio->lock, flags);
725}
726
727static int audio_pcm_open(struct snd_pcm_substream *substream)
728{
729	struct snd_pcm_runtime *runtime = substream->runtime;
730	struct audio_dev *audio = substream->private_data;
731
732	runtime->private_data = audio;
733	runtime->hw = audio_hw_info;
734	snd_pcm_limit_hw_rates(runtime);
735	runtime->hw.channels_max = 2;
736
737	audio->substream = substream;
738	return 0;
739}
740
741static int audio_pcm_close(struct snd_pcm_substream *substream)
742{
743	struct audio_dev *audio = substream->private_data;
744	unsigned long flags;
745
746	spin_lock_irqsave(&audio->lock, flags);
747	audio->substream = NULL;
748	spin_unlock_irqrestore(&audio->lock, flags);
749
750	return 0;
751}
752
753static int audio_pcm_hw_params(struct snd_pcm_substream *substream,
754				struct snd_pcm_hw_params *params)
755{
756	unsigned int channels = params_channels(params);
757	unsigned int rate = params_rate(params);
758
759	if (rate != SAMPLE_RATE)
760		return -EINVAL;
761	if (channels != 2)
762		return -EINVAL;
763
764	return snd_pcm_lib_alloc_vmalloc_buffer(substream,
765		params_buffer_bytes(params));
766}
767
768static int audio_pcm_hw_free(struct snd_pcm_substream *substream)
769{
770	return snd_pcm_lib_free_vmalloc_buffer(substream);
771}
772
773static int audio_pcm_prepare(struct snd_pcm_substream *substream)
774{
775	struct snd_pcm_runtime *runtime = substream->runtime;
776	struct audio_dev *audio = runtime->private_data;
777
778	audio->period = snd_pcm_lib_period_bytes(substream);
779	audio->period_offset = 0;
780	audio->buffer_start = runtime->dma_area;
781	audio->buffer_end = audio->buffer_start
782		+ snd_pcm_lib_buffer_bytes(substream);
783	audio->buffer_pos = audio->buffer_start;
784
785	return 0;
786}
787
788static snd_pcm_uframes_t audio_pcm_pointer(struct snd_pcm_substream *substream)
789{
790	struct snd_pcm_runtime *runtime = substream->runtime;
791	struct audio_dev *audio = runtime->private_data;
792	ssize_t bytes = audio->buffer_pos - audio->buffer_start;
793
794	/* return offset of next frame to fill in our buffer */
795	return bytes_to_frames(runtime, bytes);
796}
797
798static int audio_pcm_playback_trigger(struct snd_pcm_substream *substream,
799					int cmd)
800{
801	struct audio_dev *audio = substream->runtime->private_data;
802	int ret = 0;
803
804	switch (cmd) {
805	case SNDRV_PCM_TRIGGER_START:
806	case SNDRV_PCM_TRIGGER_RESUME:
807		audio_pcm_playback_start(audio);
808		break;
809
810	case SNDRV_PCM_TRIGGER_STOP:
811	case SNDRV_PCM_TRIGGER_SUSPEND:
812		audio_pcm_playback_stop(audio);
813		break;
814
815	default:
816		ret = -EINVAL;
817	}
818
819	return ret;
820}
821
822static struct audio_dev _audio_dev = {
823	.func = {
824		.name = "audio_source",
825		.bind = audio_bind,
826		.unbind = audio_unbind,
827		.set_alt = audio_set_alt,
828		.setup = audio_setup,
829		.disable = audio_disable,
830	},
831	.lock = __SPIN_LOCK_UNLOCKED(_audio_dev.lock),
832	.idle_reqs = LIST_HEAD_INIT(_audio_dev.idle_reqs),
833};
834
835static struct snd_pcm_ops audio_playback_ops = {
836	.open		= audio_pcm_open,
837	.close		= audio_pcm_close,
838	.ioctl		= snd_pcm_lib_ioctl,
839	.hw_params	= audio_pcm_hw_params,
840	.hw_free	= audio_pcm_hw_free,
841	.prepare	= audio_pcm_prepare,
842	.trigger	= audio_pcm_playback_trigger,
843	.pointer	= audio_pcm_pointer,
844};
845
846int audio_source_bind_config(struct usb_configuration *c,
847		struct audio_source_config *config)
848{
849	struct audio_dev *audio;
850	int err;
851
852	config->card = -1;
853	config->device = -1;
854
855	audio = &_audio_dev;
856
857	err = snd_card_setup(c, config);
858	if (err)
859		return err;
860
861	err = usb_add_function(c, &audio->func);
862	if (err)
863		goto add_fail;
864
865	return 0;
866
867add_fail:
868	snd_card_free(audio->card);
869	return err;
870}
871
872static int snd_card_setup(struct usb_configuration *c,
873		struct audio_source_config *config)
874{
875	struct audio_dev *audio;
876	struct snd_card *card;
877	struct snd_pcm *pcm;
878	int err;
879
880	audio = &_audio_dev;
881
882	err = snd_card_new(&c->cdev->gadget->dev,
883			SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
884			THIS_MODULE, 0, &card);
885	if (err)
886		return err;
887
888	err = snd_pcm_new(card, "USB audio source", 0, 1, 0, &pcm);
889	if (err)
890		goto pcm_fail;
891
892	pcm->private_data = audio;
893	pcm->info_flags = 0;
894	audio->pcm = pcm;
895
896	strlcpy(pcm->name, "USB gadget audio", sizeof(pcm->name));
897
898	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &audio_playback_ops);
899	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
900				NULL, 0, 64 * 1024);
901
902	strlcpy(card->driver, "audio_source", sizeof(card->driver));
903	strlcpy(card->shortname, card->driver, sizeof(card->shortname));
904	strlcpy(card->longname, "USB accessory audio source",
905		sizeof(card->longname));
906
907	err = snd_card_register(card);
908	if (err)
909		goto register_fail;
910
911	config->card = pcm->card->number;
912	config->device = pcm->device;
913	audio->card = card;
914	return 0;
915
916register_fail:
917pcm_fail:
918	snd_card_free(audio->card);
919	return err;
920}
921
922static struct audio_source_instance *to_audio_source_instance(
923					struct config_item *item)
924{
925	return container_of(to_config_group(item), struct audio_source_instance,
926		func_inst.group);
927}
928
929static struct audio_source_instance *to_fi_audio_source(
930					const struct usb_function_instance *fi)
931{
932	return container_of(fi, struct audio_source_instance, func_inst);
933}
934
935static void audio_source_attr_release(struct config_item *item)
936{
937	struct audio_source_instance *fi_audio = to_audio_source_instance(item);
938
939	usb_put_function_instance(&fi_audio->func_inst);
940}
941
942static int audio_source_set_inst_name(struct usb_function_instance *fi,
943					const char *name)
944{
945	struct audio_source_instance *fi_audio;
946	char *ptr;
947	int name_len;
948
949	name_len = strlen(name) + 1;
950	if (name_len > MAX_INST_NAME_LEN)
951		return -ENAMETOOLONG;
952
953	ptr = kstrndup(name, name_len, GFP_KERNEL);
954	if (!ptr)
955		return -ENOMEM;
956
957	fi_audio = to_fi_audio_source(fi);
958	fi_audio->name = ptr;
959
960	return 0;
961}
962
963static void audio_source_free_inst(struct usb_function_instance *fi)
964{
965	struct audio_source_instance *fi_audio;
966
967	fi_audio = to_fi_audio_source(fi);
968	device_destroy(fi_audio->audio_device->class,
969			fi_audio->audio_device->devt);
970	kfree(fi_audio->name);
971	kfree(fi_audio->config);
972}
973
974static ssize_t audio_source_pcm_show(struct device *dev,
975		struct device_attribute *attr, char *buf)
976{
977	struct audio_source_instance *fi_audio = dev_get_drvdata(dev);
978	struct audio_source_config *config = fi_audio->config;
979
980	/* print PCM card and device numbers */
981	return sprintf(buf, "%d %d\n", config->card, config->device);
982}
983
984struct device *create_function_device(char *name);
985
986static struct usb_function_instance *audio_source_alloc_inst(void)
987{
988	struct audio_source_instance *fi_audio;
989	struct device_attribute **attrs;
990	struct device_attribute *attr;
991	struct device *dev;
992	void *err_ptr;
993	int err = 0;
994
995	fi_audio = kzalloc(sizeof(*fi_audio), GFP_KERNEL);
996	if (!fi_audio)
997		return ERR_PTR(-ENOMEM);
998
999	fi_audio->func_inst.set_inst_name = audio_source_set_inst_name;
1000	fi_audio->func_inst.free_func_inst = audio_source_free_inst;
1001
1002	fi_audio->config = kzalloc(sizeof(struct audio_source_config),
1003							GFP_KERNEL);
1004	if (!fi_audio->config) {
1005		err_ptr = ERR_PTR(-ENOMEM);
1006		goto fail_audio;
1007	}
1008
1009	config_group_init_type_name(&fi_audio->func_inst.group, "",
1010						&audio_source_func_type);
1011	dev = create_function_device("f_audio_source");
1012
1013	if (IS_ERR(dev)) {
1014		err_ptr = dev;
1015		goto fail_audio_config;
1016	}
1017
1018	fi_audio->config->card = -1;
1019	fi_audio->config->device = -1;
1020	fi_audio->audio_device = dev;
1021
1022	attrs = audio_source_function_attributes;
1023	if (attrs) {
1024		while ((attr = *attrs++) && !err)
1025			err = device_create_file(dev, attr);
1026		if (err) {
1027			err_ptr = ERR_PTR(-EINVAL);
1028			goto fail_device;
1029		}
1030	}
1031
1032	dev_set_drvdata(dev, fi_audio);
1033	_audio_dev.config = fi_audio->config;
1034
1035	return  &fi_audio->func_inst;
1036
1037fail_device:
1038	device_destroy(dev->class, dev->devt);
1039fail_audio_config:
1040	kfree(fi_audio->config);
1041fail_audio:
1042	kfree(fi_audio);
1043	return err_ptr;
1044
1045}
1046
1047static struct usb_function *audio_source_alloc(struct usb_function_instance *fi)
1048{
1049	return &_audio_dev.func;
1050}
1051
1052DECLARE_USB_FUNCTION_INIT(audio_source, audio_source_alloc_inst,
1053			audio_source_alloc);
1054MODULE_LICENSE("GPL");
1055