1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	*/
4
5	#include <linux/gfp.h>
6	#include <linux/init.h>
7	#include <linux/ratelimit.h>
8	#include <linux/usb.h>
9	#include <linux/usb/audio.h>
10	#include <linux/slab.h>
11
12	#include <sound/core.h>
13	#include <sound/pcm.h>
14	#include <sound/pcm_params.h>
15
16	#include "usbaudio.h"
17	#include "helper.h"
18	#include "card.h"
19	#include "endpoint.h"
20	#include "pcm.h"
21	#include "clock.h"
22	#include "quirks.h"
23
24	enum {
25	EP_STATE_STOPPED,
26	EP_STATE_RUNNING,
27	EP_STATE_STOPPING,
28	};
29
30	/* interface refcounting */
31	struct snd_usb_iface_ref {
32	unsigned char iface;
33	bool need_setup;
34	int opened;
35	int altset;
36	struct list_head list;
37	};
38
39	/* clock refcounting */
40	struct snd_usb_clock_ref {
41	unsigned char clock;
42	atomic_t locked;
43	int opened;
44	int rate;
45	bool need_setup;
46	struct list_head list;
47	};
48
49	/*
50	* snd_usb_endpoint is a model that abstracts everything related to an
51	* USB endpoint and its streaming.
52	*
53	* There are functions to activate and deactivate the streaming URBs and
54	* optional callbacks to let the pcm logic handle the actual content of the
55	* packets for playback and record. Thus, the bus streaming and the audio
56	* handlers are fully decoupled.
57	*
58	* There are two different types of endpoints in audio applications.
59	*
60	* SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
61	* inbound and outbound traffic.
62	*
63	* SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
64	* expect the payload to carry Q10.14 / Q16.16 formatted sync information
65	* (3 or 4 bytes).
66	*
67	* Each endpoint has to be configured prior to being used by calling
68	* snd_usb_endpoint_set_params().
69	*
70	* The model incorporates a reference counting, so that multiple users
71	* can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
72	* only the first user will effectively start the URBs, and only the last
73	* one to stop it will tear the URBs down again.
74	*/
75
76	/*
77	* convert a sampling rate into our full speed format (fs/1000 in Q16.16)
78	* this will overflow at approx 524 kHz
79	*/
80	static inline unsigned get_usb_full_speed_rate(unsigned int rate)
81	{
82	return ((rate << 13) + 62) / 125;
83	}
84
85	/*
86	* convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
87	* this will overflow at approx 4 MHz
88	*/
89	static inline unsigned get_usb_high_speed_rate(unsigned int rate)
90	{
91	return ((rate << 10) + 62) / 125;
92	}
93
94	/*
95	* release a urb data
96	*/
97	static void release_urb_ctx(struct snd_urb_ctx *u)
98	{
99	if (u->urb && u->buffer_size)
100	usb_free_coherent(dev: u->ep->chip->dev, size: u->buffer_size,
101	addr: u->urb->transfer_buffer,
102	dma: u->urb->transfer_dma);
103	usb_free_urb(urb: u->urb);
104	u->urb = NULL;
105	u->buffer_size = 0;
106	}
107
108	static const char *usb_error_string(int err)
109	{
110	switch (err) {
111	case -ENODEV:
112	return "no device";
113	case -ENOENT:
114	return "endpoint not enabled";
115	case -EPIPE:
116	return "endpoint stalled";
117	case -ENOSPC:
118	return "not enough bandwidth";
119	case -ESHUTDOWN:
120	return "device disabled";
121	case -EHOSTUNREACH:
122	return "device suspended";
123	case -EINVAL:
124	case -EAGAIN:
125	case -EFBIG:
126	case -EMSGSIZE:
127	return "internal error";
128	default:
129	return "unknown error";
130	}
131	}
132
133	static inline bool ep_state_running(struct snd_usb_endpoint *ep)
134	{
135	return atomic_read(v: &ep->state) == EP_STATE_RUNNING;
136	}
137
138	static inline bool ep_state_update(struct snd_usb_endpoint *ep, int old, int new)
139	{
140	return atomic_try_cmpxchg(v: &ep->state, old: &old, new);
141	}
142
143	/**
144	* snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
145	*
146	* @ep: The snd_usb_endpoint
147	*
148	* Determine whether an endpoint is driven by an implicit feedback
149	* data endpoint source.
150	*/
151	int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep)
152	{
153	return ep->implicit_fb_sync && usb_pipeout(ep->pipe);
154	}
155
156	/*
157	* Return the number of samples to be sent in the next packet
158	* for streaming based on information derived from sync endpoints
159	*
160	* This won't be used for implicit feedback which takes the packet size
161	* returned from the sync source
162	*/
163	static int slave_next_packet_size(struct snd_usb_endpoint *ep,
164	unsigned int avail)
165	{
166	unsigned long flags;
167	unsigned int phase;
168	int ret;
169
170	if (ep->fill_max)
171	return ep->maxframesize;
172
173	spin_lock_irqsave(&ep->lock, flags);
174	phase = (ep->phase & 0xffff) + (ep->freqm << ep->datainterval);
175	ret = min(phase >> 16, ep->maxframesize);
176	if (avail && ret >= avail)
177	ret = -EAGAIN;
178	else
179	ep->phase = phase;
180	spin_unlock_irqrestore(lock: &ep->lock, flags);
181
182	return ret;
183	}
184
185	/*
186	* Return the number of samples to be sent in the next packet
187	* for adaptive and synchronous endpoints
188	*/
189	static int next_packet_size(struct snd_usb_endpoint *ep, unsigned int avail)
190	{
191	unsigned int sample_accum;
192	int ret;
193
194	if (ep->fill_max)
195	return ep->maxframesize;
196
197	sample_accum = ep->sample_accum + ep->sample_rem;
198	if (sample_accum >= ep->pps) {
199	sample_accum -= ep->pps;
200	ret = ep->packsize[1];
201	} else {
202	ret = ep->packsize[0];
203	}
204	if (avail && ret >= avail)
205	ret = -EAGAIN;
206	else
207	ep->sample_accum = sample_accum;
208
209	return ret;
210	}
211
212	/*
213	* snd_usb_endpoint_next_packet_size: Return the number of samples to be sent
214	* in the next packet
215	*
216	* If the size is equal or exceeds @avail, don't proceed but return -EAGAIN
217	* Exception: @avail = 0 for skipping the check.
218	*/
219	int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep,
220	struct snd_urb_ctx *ctx, int idx,
221	unsigned int avail)
222	{
223	unsigned int packet;
224
225	packet = ctx->packet_size[idx];
226	if (packet) {
227	if (avail && packet >= avail)
228	return -EAGAIN;
229	return packet;
230	}
231
232	if (ep->sync_source)
233	return slave_next_packet_size(ep, avail);
234	else
235	return next_packet_size(ep, avail);
236	}
237
238	static void call_retire_callback(struct snd_usb_endpoint *ep,
239	struct urb *urb)
240	{
241	struct snd_usb_substream *data_subs;
242
243	data_subs = READ_ONCE(ep->data_subs);
244	if (data_subs && ep->retire_data_urb)
245	ep->retire_data_urb(data_subs, urb);
246	}
247
248	static void retire_outbound_urb(struct snd_usb_endpoint *ep,
249	struct snd_urb_ctx *urb_ctx)
250	{
251	call_retire_callback(ep, urb: urb_ctx->urb);
252	}
253
254	static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
255	struct snd_usb_endpoint *sender,
256	const struct urb *urb);
257
258	static void retire_inbound_urb(struct snd_usb_endpoint *ep,
259	struct snd_urb_ctx *urb_ctx)
260	{
261	struct urb *urb = urb_ctx->urb;
262	struct snd_usb_endpoint *sync_sink;
263
264	if (unlikely(ep->skip_packets > 0)) {
265	ep->skip_packets--;
266	return;
267	}
268
269	sync_sink = READ_ONCE(ep->sync_sink);
270	if (sync_sink)
271	snd_usb_handle_sync_urb(ep: sync_sink, sender: ep, urb);
272
273	call_retire_callback(ep, urb);
274	}
275
276	static inline bool has_tx_length_quirk(struct snd_usb_audio *chip)
277	{
278	return chip->quirk_flags & QUIRK_FLAG_TX_LENGTH;
279	}
280
281	static void prepare_silent_urb(struct snd_usb_endpoint *ep,
282	struct snd_urb_ctx *ctx)
283	{
284	struct urb *urb = ctx->urb;
285	unsigned int offs = 0;
286	unsigned int extra = 0;
287	__le32 packet_length;
288	int i;
289
290	/* For tx_length_quirk, put packet length at start of packet */
291	if (has_tx_length_quirk(chip: ep->chip))
292	extra = sizeof(packet_length);
293
294	for (i = 0; i < ctx->packets; ++i) {
295	unsigned int offset;
296	unsigned int length;
297	int counts;
298
299	counts = snd_usb_endpoint_next_packet_size(ep, ctx, idx: i, avail: 0);
300	length = counts * ep->stride; /* number of silent bytes */
301	offset = offs * ep->stride + extra * i;
302	urb->iso_frame_desc[i].offset = offset;
303	urb->iso_frame_desc[i].length = length + extra;
304	if (extra) {
305	packet_length = cpu_to_le32(length);
306	memcpy(urb->transfer_buffer + offset,
307	&packet_length, sizeof(packet_length));
308	}
309	memset(urb->transfer_buffer + offset + extra,
310	ep->silence_value, length);
311	offs += counts;
312	}
313
314	urb->number_of_packets = ctx->packets;
315	urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra;
316	ctx->queued = 0;
317	}
318
319	/*
320	* Prepare a PLAYBACK urb for submission to the bus.
321	*/
322	static int prepare_outbound_urb(struct snd_usb_endpoint *ep,
323	struct snd_urb_ctx *ctx,
324	bool in_stream_lock)
325	{
326	struct urb *urb = ctx->urb;
327	unsigned char *cp = urb->transfer_buffer;
328	struct snd_usb_substream *data_subs;
329
330	urb->dev = ep->chip->dev; /* we need to set this at each time */
331
332	switch (ep->type) {
333	case SND_USB_ENDPOINT_TYPE_DATA:
334	data_subs = READ_ONCE(ep->data_subs);
335	if (data_subs && ep->prepare_data_urb)
336	return ep->prepare_data_urb(data_subs, urb, in_stream_lock);
337	/* no data provider, so send silence */
338	prepare_silent_urb(ep, ctx);
339	break;
340
341	case SND_USB_ENDPOINT_TYPE_SYNC:
342	if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
343	/*
344	* fill the length and offset of each urb descriptor.
345	* the fixed 12.13 frequency is passed as 16.16 through the pipe.
346	*/
347	urb->iso_frame_desc[0].length = 4;
348	urb->iso_frame_desc[0].offset = 0;
349	cp[0] = ep->freqn;
350	cp[1] = ep->freqn >> 8;
351	cp[2] = ep->freqn >> 16;
352	cp[3] = ep->freqn >> 24;
353	} else {
354	/*
355	* fill the length and offset of each urb descriptor.
356	* the fixed 10.14 frequency is passed through the pipe.
357	*/
358	urb->iso_frame_desc[0].length = 3;
359	urb->iso_frame_desc[0].offset = 0;
360	cp[0] = ep->freqn >> 2;
361	cp[1] = ep->freqn >> 10;
362	cp[2] = ep->freqn >> 18;
363	}
364
365	break;
366	}
367	return 0;
368	}
369
370	/*
371	* Prepare a CAPTURE or SYNC urb for submission to the bus.
372	*/
373	static int prepare_inbound_urb(struct snd_usb_endpoint *ep,
374	struct snd_urb_ctx *urb_ctx)
375	{
376	int i, offs;
377	struct urb *urb = urb_ctx->urb;
378
379	urb->dev = ep->chip->dev; /* we need to set this at each time */
380
381	switch (ep->type) {
382	case SND_USB_ENDPOINT_TYPE_DATA:
383	offs = 0;
384	for (i = 0; i < urb_ctx->packets; i++) {
385	urb->iso_frame_desc[i].offset = offs;
386	urb->iso_frame_desc[i].length = ep->curpacksize;
387	offs += ep->curpacksize;
388	}
389
390	urb->transfer_buffer_length = offs;
391	urb->number_of_packets = urb_ctx->packets;
392	break;
393
394	case SND_USB_ENDPOINT_TYPE_SYNC:
395	urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
396	urb->iso_frame_desc[0].offset = 0;
397	break;
398	}
399	return 0;
400	}
401
402	/* notify an error as XRUN to the assigned PCM data substream */
403	static void notify_xrun(struct snd_usb_endpoint *ep)
404	{
405	struct snd_usb_substream *data_subs;
406
407	data_subs = READ_ONCE(ep->data_subs);
408	if (data_subs && data_subs->pcm_substream)
409	snd_pcm_stop_xrun(substream: data_subs->pcm_substream);
410	}
411
412	static struct snd_usb_packet_info *
413	next_packet_fifo_enqueue(struct snd_usb_endpoint *ep)
414	{
415	struct snd_usb_packet_info *p;
416
417	p = ep->next_packet + (ep->next_packet_head + ep->next_packet_queued) %
418	ARRAY_SIZE(ep->next_packet);
419	ep->next_packet_queued++;
420	return p;
421	}
422
423	static struct snd_usb_packet_info *
424	next_packet_fifo_dequeue(struct snd_usb_endpoint *ep)
425	{
426	struct snd_usb_packet_info *p;
427
428	p = ep->next_packet + ep->next_packet_head;
429	ep->next_packet_head++;
430	ep->next_packet_head %= ARRAY_SIZE(ep->next_packet);
431	ep->next_packet_queued--;
432	return p;
433	}
434
435	static void push_back_to_ready_list(struct snd_usb_endpoint *ep,
436	struct snd_urb_ctx *ctx)
437	{
438	unsigned long flags;
439
440	spin_lock_irqsave(&ep->lock, flags);
441	list_add_tail(new: &ctx->ready_list, head: &ep->ready_playback_urbs);
442	spin_unlock_irqrestore(lock: &ep->lock, flags);
443	}
444
445	/*
446	* Send output urbs that have been prepared previously. URBs are dequeued
447	* from ep->ready_playback_urbs and in case there aren't any available
448	* or there are no packets that have been prepared, this function does
449	* nothing.
450	*
451	* The reason why the functionality of sending and preparing URBs is separated
452	* is that host controllers don't guarantee the order in which they return
453	* inbound and outbound packets to their submitters.
454	*
455	* This function is used both for implicit feedback endpoints and in low-
456	* latency playback mode.
457	*/
458	int snd_usb_queue_pending_output_urbs(struct snd_usb_endpoint *ep,
459	bool in_stream_lock)
460	{
461	bool implicit_fb = snd_usb_endpoint_implicit_feedback_sink(ep);
462
463	while (ep_state_running(ep)) {
464
465	unsigned long flags;
466	struct snd_usb_packet_info *packet;
467	struct snd_urb_ctx *ctx = NULL;
468	int err, i;
469
470	spin_lock_irqsave(&ep->lock, flags);
471	if ((!implicit_fb || ep->next_packet_queued > 0) &&
472	!list_empty(head: &ep->ready_playback_urbs)) {
473	/* take URB out of FIFO */
474	ctx = list_first_entry(&ep->ready_playback_urbs,
475	struct snd_urb_ctx, ready_list);
476	list_del_init(entry: &ctx->ready_list);
477	if (implicit_fb)
478	packet = next_packet_fifo_dequeue(ep);
479	}
480	spin_unlock_irqrestore(lock: &ep->lock, flags);
481
482	if (ctx == NULL)
483	break;
484
485	/* copy over the length information */
486	if (implicit_fb) {
487	for (i = 0; i < packet->packets; i++)
488	ctx->packet_size[i] = packet->packet_size[i];
489	}
490
491	/* call the data handler to fill in playback data */
492	err = prepare_outbound_urb(ep, ctx, in_stream_lock);
493	/* can be stopped during prepare callback */
494	if (unlikely(!ep_state_running(ep)))
495	break;
496	if (err < 0) {
497	/* push back to ready list again for -EAGAIN */
498	if (err == -EAGAIN) {
499	push_back_to_ready_list(ep, ctx);
500	break;
501	}
502
503	if (!in_stream_lock)
504	notify_xrun(ep);
505	return -EPIPE;
506	}
507
508	if (!atomic_read(v: &ep->chip->shutdown))
509	err = usb_submit_urb(urb: ctx->urb, GFP_ATOMIC);
510	else
511	err = -ENODEV;
512	if (err < 0) {
513	if (!atomic_read(v: &ep->chip->shutdown)) {
514	usb_audio_err(ep->chip,
515	"Unable to submit urb #%d: %d at %s\n",
516	ctx->index, err, __func__);
517	if (!in_stream_lock)
518	notify_xrun(ep);
519	}
520	return -EPIPE;
521	}
522
523	set_bit(nr: ctx->index, addr: &ep->active_mask);
524	atomic_inc(v: &ep->submitted_urbs);
525	}
526
527	return 0;
528	}
529
530	/*
531	* complete callback for urbs
532	*/
533	static void snd_complete_urb(struct urb *urb)
534	{
535	struct snd_urb_ctx *ctx = urb->context;
536	struct snd_usb_endpoint *ep = ctx->ep;
537	int err;
538
539	if (unlikely(urb->status == -ENOENT || /* unlinked */
540	urb->status == -ENODEV || /* device removed */
541	urb->status == -ECONNRESET || /* unlinked */
542	urb->status == -ESHUTDOWN)) /* device disabled */
543	goto exit_clear;
544	/* device disconnected */
545	if (unlikely(atomic_read(&ep->chip->shutdown)))
546	goto exit_clear;
547
548	if (unlikely(!ep_state_running(ep)))
549	goto exit_clear;
550
551	if (usb_pipeout(ep->pipe)) {
552	retire_outbound_urb(ep, urb_ctx: ctx);
553	/* can be stopped during retire callback */
554	if (unlikely(!ep_state_running(ep)))
555	goto exit_clear;
556
557	/* in low-latency and implicit-feedback modes, push back the
558	* URB to ready list at first, then process as much as possible
559	*/
560	if (ep->lowlatency_playback ||
561	snd_usb_endpoint_implicit_feedback_sink(ep)) {
562	push_back_to_ready_list(ep, ctx);
563	clear_bit(nr: ctx->index, addr: &ep->active_mask);
564	snd_usb_queue_pending_output_urbs(ep, in_stream_lock: false);
565	atomic_dec(v: &ep->submitted_urbs); /* decrement at last */
566	return;
567	}
568
569	/* in non-lowlatency mode, no error handling for prepare */
570	prepare_outbound_urb(ep, ctx, in_stream_lock: false);
571	/* can be stopped during prepare callback */
572	if (unlikely(!ep_state_running(ep)))
573	goto exit_clear;
574	} else {
575	retire_inbound_urb(ep, urb_ctx: ctx);
576	/* can be stopped during retire callback */
577	if (unlikely(!ep_state_running(ep)))
578	goto exit_clear;
579
580	prepare_inbound_urb(ep, urb_ctx: ctx);
581	}
582
583	if (!atomic_read(v: &ep->chip->shutdown))
584	err = usb_submit_urb(urb, GFP_ATOMIC);
585	else
586	err = -ENODEV;
587	if (err == 0)
588	return;
589
590	if (!atomic_read(v: &ep->chip->shutdown)) {
591	usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
592	notify_xrun(ep);
593	}
594
595	exit_clear:
596	clear_bit(nr: ctx->index, addr: &ep->active_mask);
597	atomic_dec(v: &ep->submitted_urbs);
598	}
599
600	/*
601	* Find or create a refcount object for the given interface
602	*
603	* The objects are released altogether in snd_usb_endpoint_free_all()
604	*/
605	static struct snd_usb_iface_ref *
606	iface_ref_find(struct snd_usb_audio *chip, int iface)
607	{
608	struct snd_usb_iface_ref *ip;
609
610	list_for_each_entry(ip, &chip->iface_ref_list, list)
611	if (ip->iface == iface)
612	return ip;
613
614	ip = kzalloc(size: sizeof(*ip), GFP_KERNEL);
615	if (!ip)
616	return NULL;
617	ip->iface = iface;
618	list_add_tail(new: &ip->list, head: &chip->iface_ref_list);
619	return ip;
620	}
621
622	/* Similarly, a refcount object for clock */
623	static struct snd_usb_clock_ref *
624	clock_ref_find(struct snd_usb_audio *chip, int clock)
625	{
626	struct snd_usb_clock_ref *ref;
627
628	list_for_each_entry(ref, &chip->clock_ref_list, list)
629	if (ref->clock == clock)
630	return ref;
631
632	ref = kzalloc(size: sizeof(*ref), GFP_KERNEL);
633	if (!ref)
634	return NULL;
635	ref->clock = clock;
636	atomic_set(v: &ref->locked, i: 0);
637	list_add_tail(new: &ref->list, head: &chip->clock_ref_list);
638	return ref;
639	}
640
641	/*
642	* Get the existing endpoint object corresponding EP
643	* Returns NULL if not present.
644	*/
645	struct snd_usb_endpoint *
646	snd_usb_get_endpoint(struct snd_usb_audio *chip, int ep_num)
647	{
648	struct snd_usb_endpoint *ep;
649
650	list_for_each_entry(ep, &chip->ep_list, list) {
651	if (ep->ep_num == ep_num)
652	return ep;
653	}
654
655	return NULL;
656	}
657
658	#define ep_type_name(type) \
659	(type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync")
660
661	/**
662	* snd_usb_add_endpoint: Add an endpoint to an USB audio chip
663	*
664	* @chip: The chip
665	* @ep_num: The number of the endpoint to use
666	* @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
667	*
668	* If the requested endpoint has not been added to the given chip before,
669	* a new instance is created.
670	*
671	* Returns zero on success or a negative error code.
672	*
673	* New endpoints will be added to chip->ep_list and freed by
674	* calling snd_usb_endpoint_free_all().
675	*
676	* For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that
677	* bNumEndpoints > 1 beforehand.
678	*/
679	int snd_usb_add_endpoint(struct snd_usb_audio *chip, int ep_num, int type)
680	{
681	struct snd_usb_endpoint *ep;
682	bool is_playback;
683
684	ep = snd_usb_get_endpoint(chip, ep_num);
685	if (ep)
686	return 0;
687
688	usb_audio_dbg(chip, "Creating new %s endpoint #%x\n",
689	ep_type_name(type),
690	ep_num);
691	ep = kzalloc(size: sizeof(*ep), GFP_KERNEL);
692	if (!ep)
693	return -ENOMEM;
694
695	ep->chip = chip;
696	spin_lock_init(&ep->lock);
697	ep->type = type;
698	ep->ep_num = ep_num;
699	INIT_LIST_HEAD(list: &ep->ready_playback_urbs);
700	atomic_set(v: &ep->submitted_urbs, i: 0);
701
702	is_playback = ((ep_num & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
703	ep_num &= USB_ENDPOINT_NUMBER_MASK;
704	if (is_playback)
705	ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
706	else
707	ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
708
709	list_add_tail(new: &ep->list, head: &chip->ep_list);
710	return 0;
711	}
712
713	/* Set up syncinterval and maxsyncsize for a sync EP */
714	static void endpoint_set_syncinterval(struct snd_usb_audio *chip,
715	struct snd_usb_endpoint *ep)
716	{
717	struct usb_host_interface *alts;
718	struct usb_endpoint_descriptor *desc;
719
720	alts = snd_usb_get_host_interface(chip, ifnum: ep->iface, altsetting: ep->altsetting);
721	if (!alts)
722	return;
723
724	desc = get_endpoint(alts, ep->ep_idx);
725	if (desc->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
726	desc->bRefresh >= 1 && desc->bRefresh <= 9)
727	ep->syncinterval = desc->bRefresh;
728	else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
729	ep->syncinterval = 1;
730	else if (desc->bInterval >= 1 && desc->bInterval <= 16)
731	ep->syncinterval = desc->bInterval - 1;
732	else
733	ep->syncinterval = 3;
734
735	ep->syncmaxsize = le16_to_cpu(desc->wMaxPacketSize);
736	}
737
738	static bool endpoint_compatible(struct snd_usb_endpoint *ep,
739	const struct audioformat *fp,
740	const struct snd_pcm_hw_params *params)
741	{
742	if (!ep->opened)
743	return false;
744	if (ep->cur_audiofmt != fp)
745	return false;
746	if (ep->cur_rate != params_rate(p: params) ||
747	ep->cur_format != params_format(p: params) ||
748	ep->cur_period_frames != params_period_size(p: params) ||
749	ep->cur_buffer_periods != params_periods(p: params))
750	return false;
751	return true;
752	}
753
754	/*
755	* Check whether the given fp and hw params are compatible with the current
756	* setup of the target EP for implicit feedback sync
757	*/
758	bool snd_usb_endpoint_compatible(struct snd_usb_audio *chip,
759	struct snd_usb_endpoint *ep,
760	const struct audioformat *fp,
761	const struct snd_pcm_hw_params *params)
762	{
763	bool ret;
764
765	mutex_lock(&chip->mutex);
766	ret = endpoint_compatible(ep, fp, params);
767	mutex_unlock(lock: &chip->mutex);
768	return ret;
769	}
770
771	/*
772	* snd_usb_endpoint_open: Open the endpoint
773	*
774	* Called from hw_params to assign the endpoint to the substream.
775	* It's reference-counted, and only the first opener is allowed to set up
776	* arbitrary parameters. The later opener must be compatible with the
777	* former opened parameters.
778	* The endpoint needs to be closed via snd_usb_endpoint_close() later.
779	*
780	* Note that this function doesn't configure the endpoint. The substream
781	* needs to set it up later via snd_usb_endpoint_set_params() and
782	* snd_usb_endpoint_prepare().
783	*/
784	struct snd_usb_endpoint *
785	snd_usb_endpoint_open(struct snd_usb_audio *chip,
786	const struct audioformat *fp,
787	const struct snd_pcm_hw_params *params,
788	bool is_sync_ep,
789	bool fixed_rate)
790	{
791	struct snd_usb_endpoint *ep;
792	int ep_num = is_sync_ep ? fp->sync_ep : fp->endpoint;
793
794	mutex_lock(&chip->mutex);
795	ep = snd_usb_get_endpoint(chip, ep_num);
796	if (!ep) {
797	usb_audio_err(chip, "Cannot find EP 0x%x to open\n", ep_num);
798	goto unlock;
799	}
800
801	if (!ep->opened) {
802	if (is_sync_ep) {
803	ep->iface = fp->sync_iface;
804	ep->altsetting = fp->sync_altsetting;
805	ep->ep_idx = fp->sync_ep_idx;
806	} else {
807	ep->iface = fp->iface;
808	ep->altsetting = fp->altsetting;
809	ep->ep_idx = fp->ep_idx;
810	}
811	usb_audio_dbg(chip, "Open EP 0x%x, iface=%d:%d, idx=%d\n",
812	ep_num, ep->iface, ep->altsetting, ep->ep_idx);
813
814	ep->iface_ref = iface_ref_find(chip, iface: ep->iface);
815	if (!ep->iface_ref) {
816	ep = NULL;
817	goto unlock;
818	}
819
820	if (fp->protocol != UAC_VERSION_1) {
821	ep->clock_ref = clock_ref_find(chip, clock: fp->clock);
822	if (!ep->clock_ref) {
823	ep = NULL;
824	goto unlock;
825	}
826	ep->clock_ref->opened++;
827	}
828
829	ep->cur_audiofmt = fp;
830	ep->cur_channels = fp->channels;
831	ep->cur_rate = params_rate(p: params);
832	ep->cur_format = params_format(p: params);
833	ep->cur_frame_bytes = snd_pcm_format_physical_width(format: ep->cur_format) *
834	ep->cur_channels / 8;
835	ep->cur_period_frames = params_period_size(p: params);
836	ep->cur_period_bytes = ep->cur_period_frames * ep->cur_frame_bytes;
837	ep->cur_buffer_periods = params_periods(p: params);
838
839	if (ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
840	endpoint_set_syncinterval(chip, ep);
841
842	ep->implicit_fb_sync = fp->implicit_fb;
843	ep->need_setup = true;
844	ep->need_prepare = true;
845	ep->fixed_rate = fixed_rate;
846
847	usb_audio_dbg(chip, " channels=%d, rate=%d, format=%s, period_bytes=%d, periods=%d, implicit_fb=%d\n",
848	ep->cur_channels, ep->cur_rate,
849	snd_pcm_format_name(ep->cur_format),
850	ep->cur_period_bytes, ep->cur_buffer_periods,
851	ep->implicit_fb_sync);
852
853	} else {
854	if (WARN_ON(!ep->iface_ref)) {
855	ep = NULL;
856	goto unlock;
857	}
858
859	if (!endpoint_compatible(ep, fp, params)) {
860	usb_audio_err(chip, "Incompatible EP setup for 0x%x\n",
861	ep_num);
862	ep = NULL;
863	goto unlock;
864	}
865
866	usb_audio_dbg(chip, "Reopened EP 0x%x (count %d)\n",
867	ep_num, ep->opened);
868	}
869
870	if (!ep->iface_ref->opened++)
871	ep->iface_ref->need_setup = true;
872
873	ep->opened++;
874
875	unlock:
876	mutex_unlock(lock: &chip->mutex);
877	return ep;
878	}
879
880	/*
881	* snd_usb_endpoint_set_sync: Link data and sync endpoints
882	*
883	* Pass NULL to sync_ep to unlink again
884	*/
885	void snd_usb_endpoint_set_sync(struct snd_usb_audio *chip,
886	struct snd_usb_endpoint *data_ep,
887	struct snd_usb_endpoint *sync_ep)
888	{
889	data_ep->sync_source = sync_ep;
890	}
891
892	/*
893	* Set data endpoint callbacks and the assigned data stream
894	*
895	* Called at PCM trigger and cleanups.
896	* Pass NULL to deactivate each callback.
897	*/
898	void snd_usb_endpoint_set_callback(struct snd_usb_endpoint *ep,
899	int (*prepare)(struct snd_usb_substream *subs,
900	struct urb *urb,
901	bool in_stream_lock),
902	void (*retire)(struct snd_usb_substream *subs,
903	struct urb *urb),
904	struct snd_usb_substream *data_subs)
905	{
906	ep->prepare_data_urb = prepare;
907	ep->retire_data_urb = retire;
908	if (data_subs)
909	ep->lowlatency_playback = data_subs->lowlatency_playback;
910	else
911	ep->lowlatency_playback = false;
912	WRITE_ONCE(ep->data_subs, data_subs);
913	}
914
915	static int endpoint_set_interface(struct snd_usb_audio *chip,
916	struct snd_usb_endpoint *ep,
917	bool set)
918	{
919	int altset = set ? ep->altsetting : 0;
920	int err;
921
922	if (ep->iface_ref->altset == altset)
923	return 0;
924
925	usb_audio_dbg(chip, "Setting usb interface %d:%d for EP 0x%x\n",
926	ep->iface, altset, ep->ep_num);
927	err = usb_set_interface(dev: chip->dev, ifnum: ep->iface, alternate: altset);
928	if (err < 0) {
929	usb_audio_err_ratelimited(
930	chip, "%d:%d: usb_set_interface failed (%d)\n",
931	ep->iface, altset, err);
932	return err;
933	}
934
935	if (chip->quirk_flags & QUIRK_FLAG_IFACE_DELAY)
936	msleep(msecs: 50);
937	ep->iface_ref->altset = altset;
938	return 0;
939	}
940
941	/*
942	* snd_usb_endpoint_close: Close the endpoint
943	*
944	* Unreference the already opened endpoint via snd_usb_endpoint_open().
945	*/
946	void snd_usb_endpoint_close(struct snd_usb_audio *chip,
947	struct snd_usb_endpoint *ep)
948	{
949	mutex_lock(&chip->mutex);
950	usb_audio_dbg(chip, "Closing EP 0x%x (count %d)\n",
951	ep->ep_num, ep->opened);
952
953	if (!--ep->iface_ref->opened &&
954	!(chip->quirk_flags & QUIRK_FLAG_IFACE_SKIP_CLOSE))
955	endpoint_set_interface(chip, ep, set: false);
956
957	if (!--ep->opened) {
958	if (ep->clock_ref) {
959	if (!--ep->clock_ref->opened)
960	ep->clock_ref->rate = 0;
961	}
962	ep->iface = 0;
963	ep->altsetting = 0;
964	ep->cur_audiofmt = NULL;
965	ep->cur_rate = 0;
966	ep->iface_ref = NULL;
967	ep->clock_ref = NULL;
968	usb_audio_dbg(chip, "EP 0x%x closed\n", ep->ep_num);
969	}
970	mutex_unlock(lock: &chip->mutex);
971	}
972
973	/* Prepare for suspening EP, called from the main suspend handler */
974	void snd_usb_endpoint_suspend(struct snd_usb_endpoint *ep)
975	{
976	ep->need_prepare = true;
977	if (ep->iface_ref)
978	ep->iface_ref->need_setup = true;
979	if (ep->clock_ref)
980	ep->clock_ref->rate = 0;
981	}
982
983	/*
984	* wait until all urbs are processed.
985	*/
986	static int wait_clear_urbs(struct snd_usb_endpoint *ep)
987	{
988	unsigned long end_time = jiffies + msecs_to_jiffies(m: 1000);
989	int alive;
990
991	if (atomic_read(v: &ep->state) != EP_STATE_STOPPING)
992	return 0;
993
994	do {
995	alive = atomic_read(v: &ep->submitted_urbs);
996	if (!alive)
997	break;
998
999	schedule_timeout_uninterruptible(timeout: 1);
1000	} while (time_before(jiffies, end_time));
1001
1002	if (alive)
1003	usb_audio_err(ep->chip,
1004	"timeout: still %d active urbs on EP #%x\n",
1005	alive, ep->ep_num);
1006
1007	if (ep_state_update(ep, old: EP_STATE_STOPPING, new: EP_STATE_STOPPED)) {
1008	ep->sync_sink = NULL;
1009	snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL);
1010	}
1011
1012	return 0;
1013	}
1014
1015	/* sync the pending stop operation;
1016	* this function itself doesn't trigger the stop operation
1017	*/
1018	void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep)
1019	{
1020	if (ep)
1021	wait_clear_urbs(ep);
1022	}
1023
1024	/*
1025	* Stop active urbs
1026	*
1027	* This function moves the EP to STOPPING state if it's being RUNNING.
1028	*/
1029	static int stop_urbs(struct snd_usb_endpoint *ep, bool force, bool keep_pending)
1030	{
1031	unsigned int i;
1032	unsigned long flags;
1033
1034	if (!force && atomic_read(v: &ep->running))
1035	return -EBUSY;
1036
1037	if (!ep_state_update(ep, old: EP_STATE_RUNNING, new: EP_STATE_STOPPING))
1038	return 0;
1039
1040	spin_lock_irqsave(&ep->lock, flags);
1041	INIT_LIST_HEAD(list: &ep->ready_playback_urbs);
1042	ep->next_packet_head = 0;
1043	ep->next_packet_queued = 0;
1044	spin_unlock_irqrestore(lock: &ep->lock, flags);
1045
1046	if (keep_pending)
1047	return 0;
1048
1049	for (i = 0; i < ep->nurbs; i++) {
1050	if (test_bit(i, &ep->active_mask)) {
1051	if (!test_and_set_bit(nr: i, addr: &ep->unlink_mask)) {
1052	struct urb *u = ep->urb[i].urb;
1053	usb_unlink_urb(urb: u);
1054	}
1055	}
1056	}
1057
1058	return 0;
1059	}
1060
1061	/*
1062	* release an endpoint's urbs
1063	*/
1064	static int release_urbs(struct snd_usb_endpoint *ep, bool force)
1065	{
1066	int i, err;
1067
1068	/* route incoming urbs to nirvana */
1069	snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL);
1070
1071	/* stop and unlink urbs */
1072	err = stop_urbs(ep, force, keep_pending: false);
1073	if (err)
1074	return err;
1075
1076	wait_clear_urbs(ep);
1077
1078	for (i = 0; i < ep->nurbs; i++)
1079	release_urb_ctx(u: &ep->urb[i]);
1080
1081	usb_free_coherent(dev: ep->chip->dev, SYNC_URBS * 4,
1082	addr: ep->syncbuf, dma: ep->sync_dma);
1083
1084	ep->syncbuf = NULL;
1085	ep->nurbs = 0;
1086	return 0;
1087	}
1088
1089	/*
1090	* configure a data endpoint
1091	*/
1092	static int data_ep_set_params(struct snd_usb_endpoint *ep)
1093	{
1094	struct snd_usb_audio *chip = ep->chip;
1095	unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
1096	unsigned int max_packs_per_period, urbs_per_period, urb_packs;
1097	unsigned int max_urbs, i;
1098	const struct audioformat *fmt = ep->cur_audiofmt;
1099	int frame_bits = ep->cur_frame_bytes * 8;
1100	int tx_length_quirk = (has_tx_length_quirk(chip) &&
1101	usb_pipeout(ep->pipe));
1102
1103	usb_audio_dbg(chip, "Setting params for data EP 0x%x, pipe 0x%x\n",
1104	ep->ep_num, ep->pipe);
1105
1106	if (ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
1107	/*
1108	* When operating in DSD DOP mode, the size of a sample frame
1109	* in hardware differs from the actual physical format width
1110	* because we need to make room for the DOP markers.
1111	*/
1112	frame_bits += ep->cur_channels << 3;
1113	}
1114
1115	ep->datainterval = fmt->datainterval;
1116	ep->stride = frame_bits >> 3;
1117
1118	switch (ep->cur_format) {
1119	case SNDRV_PCM_FORMAT_U8:
1120	ep->silence_value = 0x80;
1121	break;
1122	case SNDRV_PCM_FORMAT_DSD_U8:
1123	case SNDRV_PCM_FORMAT_DSD_U16_LE:
1124	case SNDRV_PCM_FORMAT_DSD_U32_LE:
1125	case SNDRV_PCM_FORMAT_DSD_U16_BE:
1126	case SNDRV_PCM_FORMAT_DSD_U32_BE:
1127	ep->silence_value = 0x69;
1128	break;
1129	default:
1130	ep->silence_value = 0;
1131	}
1132
1133	/* assume max. frequency is 50% higher than nominal */
1134	ep->freqmax = ep->freqn + (ep->freqn >> 1);
1135	/* Round up freqmax to nearest integer in order to calculate maximum
1136	* packet size, which must represent a whole number of frames.
1137	* This is accomplished by adding 0x0.ffff before converting the
1138	* Q16.16 format into integer.
1139	* In order to accurately calculate the maximum packet size when
1140	* the data interval is more than 1 (i.e. ep->datainterval > 0),
1141	* multiply by the data interval prior to rounding. For instance,
1142	* a freqmax of 41 kHz will result in a max packet size of 6 (5.125)
1143	* frames with a data interval of 1, but 11 (10.25) frames with a
1144	* data interval of 2.
1145	* (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
1146	* maximum datainterval value of 3, at USB full speed, higher for
1147	* USB high speed, noting that ep->freqmax is in units of
1148	* frames per packet in Q16.16 format.)
1149	*/
1150	maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
1151	(frame_bits >> 3);
1152	if (tx_length_quirk)
1153	maxsize += sizeof(__le32); /* Space for length descriptor */
1154	/* but wMaxPacketSize might reduce this */
1155	if (ep->maxpacksize && ep->maxpacksize < maxsize) {
1156	/* whatever fits into a max. size packet */
1157	unsigned int data_maxsize = maxsize = ep->maxpacksize;
1158
1159	if (tx_length_quirk)
1160	/* Need to remove the length descriptor to calc freq */
1161	data_maxsize -= sizeof(__le32);
1162	ep->freqmax = (data_maxsize / (frame_bits >> 3))
1163	<< (16 - ep->datainterval);
1164	}
1165
1166	if (ep->fill_max)
1167	ep->curpacksize = ep->maxpacksize;
1168	else
1169	ep->curpacksize = maxsize;
1170
1171	if (snd_usb_get_speed(chip->dev) != USB_SPEED_FULL) {
1172	packs_per_ms = 8 >> ep->datainterval;
1173	max_packs_per_urb = MAX_PACKS_HS;
1174	} else {
1175	packs_per_ms = 1;
1176	max_packs_per_urb = MAX_PACKS;
1177	}
1178	if (ep->sync_source && !ep->implicit_fb_sync)
1179	max_packs_per_urb = min(max_packs_per_urb,
1180	1U << ep->sync_source->syncinterval);
1181	max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
1182
1183	/*
1184	* Capture endpoints need to use small URBs because there's no way
1185	* to tell in advance where the next period will end, and we don't
1186	* want the next URB to complete much after the period ends.
1187	*
1188	* Playback endpoints with implicit sync much use the same parameters
1189	* as their corresponding capture endpoint.
1190	*/
1191	if (usb_pipein(ep->pipe) || ep->implicit_fb_sync) {
1192
1193	/* make capture URBs <= 1 ms and smaller than a period */
1194	urb_packs = min(max_packs_per_urb, packs_per_ms);
1195	while (urb_packs > 1 && urb_packs * maxsize >= ep->cur_period_bytes)
1196	urb_packs >>= 1;
1197	ep->nurbs = MAX_URBS;
1198
1199	/*
1200	* Playback endpoints without implicit sync are adjusted so that
1201	* a period fits as evenly as possible in the smallest number of
1202	* URBs. The total number of URBs is adjusted to the size of the
1203	* ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits.
1204	*/
1205	} else {
1206	/* determine how small a packet can be */
1207	minsize = (ep->freqn >> (16 - ep->datainterval)) *
1208	(frame_bits >> 3);
1209	/* with sync from device, assume it can be 12% lower */
1210	if (ep->sync_source)
1211	minsize -= minsize >> 3;
1212	minsize = max(minsize, 1u);
1213
1214	/* how many packets will contain an entire ALSA period? */
1215	max_packs_per_period = DIV_ROUND_UP(ep->cur_period_bytes, minsize);
1216
1217	/* how many URBs will contain a period? */
1218	urbs_per_period = DIV_ROUND_UP(max_packs_per_period,
1219	max_packs_per_urb);
1220	/* how many packets are needed in each URB? */
1221	urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);
1222
1223	/* limit the number of frames in a single URB */
1224	ep->max_urb_frames = DIV_ROUND_UP(ep->cur_period_frames,
1225	urbs_per_period);
1226
1227	/* try to use enough URBs to contain an entire ALSA buffer */
1228	max_urbs = min((unsigned) MAX_URBS,
1229	MAX_QUEUE * packs_per_ms / urb_packs);
1230	ep->nurbs = min(max_urbs, urbs_per_period * ep->cur_buffer_periods);
1231	}
1232
1233	/* allocate and initialize data urbs */
1234	for (i = 0; i < ep->nurbs; i++) {
1235	struct snd_urb_ctx *u = &ep->urb[i];
1236	u->index = i;
1237	u->ep = ep;
1238	u->packets = urb_packs;
1239	u->buffer_size = maxsize * u->packets;
1240
1241	if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
1242	u->packets++; /* for transfer delimiter */
1243	u->urb = usb_alloc_urb(iso_packets: u->packets, GFP_KERNEL);
1244	if (!u->urb)
1245	goto out_of_memory;
1246
1247	u->urb->transfer_buffer =
1248	usb_alloc_coherent(dev: chip->dev, size: u->buffer_size,
1249	GFP_KERNEL, dma: &u->urb->transfer_dma);
1250	if (!u->urb->transfer_buffer)
1251	goto out_of_memory;
1252	u->urb->pipe = ep->pipe;
1253	u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1254	u->urb->interval = 1 << ep->datainterval;
1255	u->urb->context = u;
1256	u->urb->complete = snd_complete_urb;
1257	INIT_LIST_HEAD(list: &u->ready_list);
1258	}
1259
1260	return 0;
1261
1262	out_of_memory:
1263	release_urbs(ep, force: false);
1264	return -ENOMEM;
1265	}
1266
1267	/*
1268	* configure a sync endpoint
1269	*/
1270	static int sync_ep_set_params(struct snd_usb_endpoint *ep)
1271	{
1272	struct snd_usb_audio *chip = ep->chip;
1273	int i;
1274
1275	usb_audio_dbg(chip, "Setting params for sync EP 0x%x, pipe 0x%x\n",
1276	ep->ep_num, ep->pipe);
1277
1278	ep->syncbuf = usb_alloc_coherent(dev: chip->dev, SYNC_URBS * 4,
1279	GFP_KERNEL, dma: &ep->sync_dma);
1280	if (!ep->syncbuf)
1281	return -ENOMEM;
1282
1283	ep->nurbs = SYNC_URBS;
1284	for (i = 0; i < SYNC_URBS; i++) {
1285	struct snd_urb_ctx *u = &ep->urb[i];
1286	u->index = i;
1287	u->ep = ep;
1288	u->packets = 1;
1289	u->urb = usb_alloc_urb(iso_packets: 1, GFP_KERNEL);
1290	if (!u->urb)
1291	goto out_of_memory;
1292	u->urb->transfer_buffer = ep->syncbuf + i * 4;
1293	u->urb->transfer_dma = ep->sync_dma + i * 4;
1294	u->urb->transfer_buffer_length = 4;
1295	u->urb->pipe = ep->pipe;
1296	u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1297	u->urb->number_of_packets = 1;
1298	u->urb->interval = 1 << ep->syncinterval;
1299	u->urb->context = u;
1300	u->urb->complete = snd_complete_urb;
1301	}
1302
1303	return 0;
1304
1305	out_of_memory:
1306	release_urbs(ep, force: false);
1307	return -ENOMEM;
1308	}
1309
1310	/* update the rate of the referred clock; return the actual rate */
1311	static int update_clock_ref_rate(struct snd_usb_audio *chip,
1312	struct snd_usb_endpoint *ep)
1313	{
1314	struct snd_usb_clock_ref *clock = ep->clock_ref;
1315	int rate = ep->cur_rate;
1316
1317	if (!clock || clock->rate == rate)
1318	return rate;
1319	if (clock->rate) {
1320	if (atomic_read(v: &clock->locked))
1321	return clock->rate;
1322	if (clock->rate != rate) {
1323	usb_audio_err(chip, "Mismatched sample rate %d vs %d for EP 0x%x\n",
1324	clock->rate, rate, ep->ep_num);
1325	return clock->rate;
1326	}
1327	}
1328	clock->rate = rate;
1329	clock->need_setup = true;
1330	return rate;
1331	}
1332
1333	/*
1334	* snd_usb_endpoint_set_params: configure an snd_usb_endpoint
1335	*
1336	* It's called either from hw_params callback.
1337	* Determine the number of URBs to be used on this endpoint.
1338	* An endpoint must be configured before it can be started.
1339	* An endpoint that is already running can not be reconfigured.
1340	*/
1341	int snd_usb_endpoint_set_params(struct snd_usb_audio *chip,
1342	struct snd_usb_endpoint *ep)
1343	{
1344	const struct audioformat *fmt = ep->cur_audiofmt;
1345	int err = 0;
1346
1347	mutex_lock(&chip->mutex);
1348	if (!ep->need_setup)
1349	goto unlock;
1350
1351	/* release old buffers, if any */
1352	err = release_urbs(ep, force: false);
1353	if (err < 0)
1354	goto unlock;
1355
1356	ep->datainterval = fmt->datainterval;
1357	ep->maxpacksize = fmt->maxpacksize;
1358	ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
1359
1360	if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) {
1361	ep->freqn = get_usb_full_speed_rate(rate: ep->cur_rate);
1362	ep->pps = 1000 >> ep->datainterval;
1363	} else {
1364	ep->freqn = get_usb_high_speed_rate(rate: ep->cur_rate);
1365	ep->pps = 8000 >> ep->datainterval;
1366	}
1367
1368	ep->sample_rem = ep->cur_rate % ep->pps;
1369	ep->packsize[0] = ep->cur_rate / ep->pps;
1370	ep->packsize[1] = (ep->cur_rate + (ep->pps - 1)) / ep->pps;
1371
1372	/* calculate the frequency in 16.16 format */
1373	ep->freqm = ep->freqn;
1374	ep->freqshift = INT_MIN;
1375
1376	ep->phase = 0;
1377
1378	switch (ep->type) {
1379	case SND_USB_ENDPOINT_TYPE_DATA:
1380	err = data_ep_set_params(ep);
1381	break;
1382	case SND_USB_ENDPOINT_TYPE_SYNC:
1383	err = sync_ep_set_params(ep);
1384	break;
1385	default:
1386	err = -EINVAL;
1387	}
1388
1389	usb_audio_dbg(chip, "Set up %d URBS, ret=%d\n", ep->nurbs, err);
1390
1391	if (err < 0)
1392	goto unlock;
1393
1394	/* some unit conversions in runtime */
1395	ep->maxframesize = ep->maxpacksize / ep->cur_frame_bytes;
1396	ep->curframesize = ep->curpacksize / ep->cur_frame_bytes;
1397
1398	err = update_clock_ref_rate(chip, ep);
1399	if (err >= 0) {
1400	ep->need_setup = false;
1401	err = 0;
1402	}
1403
1404	unlock:
1405	mutex_unlock(lock: &chip->mutex);
1406	return err;
1407	}
1408
1409	static int init_sample_rate(struct snd_usb_audio *chip,
1410	struct snd_usb_endpoint *ep)
1411	{
1412	struct snd_usb_clock_ref *clock = ep->clock_ref;
1413	int rate, err;
1414
1415	rate = update_clock_ref_rate(chip, ep);
1416	if (rate < 0)
1417	return rate;
1418	if (clock && !clock->need_setup)
1419	return 0;
1420
1421	if (!ep->fixed_rate) {
1422	err = snd_usb_init_sample_rate(chip, fmt: ep->cur_audiofmt, rate);
1423	if (err < 0) {
1424	if (clock)
1425	clock->rate = 0; /* reset rate */
1426	return err;
1427	}
1428	}
1429
1430	if (clock)
1431	clock->need_setup = false;
1432	return 0;
1433	}
1434
1435	/*
1436	* snd_usb_endpoint_prepare: Prepare the endpoint
1437	*
1438	* This function sets up the EP to be fully usable state.
1439	* It's called either from prepare callback.
1440	* The function checks need_setup flag, and performs nothing unless needed,
1441	* so it's safe to call this multiple times.
1442	*
1443	* This returns zero if unchanged, 1 if the configuration has changed,
1444	* or a negative error code.
1445	*/
1446	int snd_usb_endpoint_prepare(struct snd_usb_audio *chip,
1447	struct snd_usb_endpoint *ep)
1448	{
1449	bool iface_first;
1450	int err = 0;
1451
1452	mutex_lock(&chip->mutex);
1453	if (WARN_ON(!ep->iface_ref))
1454	goto unlock;
1455	if (!ep->need_prepare)
1456	goto unlock;
1457
1458	/* If the interface has been already set up, just set EP parameters */
1459	if (!ep->iface_ref->need_setup) {
1460	/* sample rate setup of UAC1 is per endpoint, and we need
1461	* to update at each EP configuration
1462	*/
1463	if (ep->cur_audiofmt->protocol == UAC_VERSION_1) {
1464	err = init_sample_rate(chip, ep);
1465	if (err < 0)
1466	goto unlock;
1467	}
1468	goto done;
1469	}
1470
1471	/* Need to deselect altsetting at first */
1472	endpoint_set_interface(chip, ep, set: false);
1473
1474	/* Some UAC1 devices (e.g. Yamaha THR10) need the host interface
1475	* to be set up before parameter setups
1476	*/
1477	iface_first = ep->cur_audiofmt->protocol == UAC_VERSION_1;
1478	/* Workaround for devices that require the interface setup at first like UAC1 */
1479	if (chip->quirk_flags & QUIRK_FLAG_SET_IFACE_FIRST)
1480	iface_first = true;
1481	if (iface_first) {
1482	err = endpoint_set_interface(chip, ep, set: true);
1483	if (err < 0)
1484	goto unlock;
1485	}
1486
1487	err = snd_usb_init_pitch(chip, fmt: ep->cur_audiofmt);
1488	if (err < 0)
1489	goto unlock;
1490
1491	err = init_sample_rate(chip, ep);
1492	if (err < 0)
1493	goto unlock;
1494
1495	err = snd_usb_select_mode_quirk(chip, fmt: ep->cur_audiofmt);
1496	if (err < 0)
1497	goto unlock;
1498
1499	/* for UAC2/3, enable the interface altset here at last */
1500	if (!iface_first) {
1501	err = endpoint_set_interface(chip, ep, set: true);
1502	if (err < 0)
1503	goto unlock;
1504	}
1505
1506	ep->iface_ref->need_setup = false;
1507
1508	done:
1509	ep->need_prepare = false;
1510	err = 1;
1511
1512	unlock:
1513	mutex_unlock(lock: &chip->mutex);
1514	return err;
1515	}
1516
1517	/* get the current rate set to the given clock by any endpoint */
1518	int snd_usb_endpoint_get_clock_rate(struct snd_usb_audio *chip, int clock)
1519	{
1520	struct snd_usb_clock_ref *ref;
1521	int rate = 0;
1522
1523	if (!clock)
1524	return 0;
1525	mutex_lock(&chip->mutex);
1526	list_for_each_entry(ref, &chip->clock_ref_list, list) {
1527	if (ref->clock == clock) {
1528	rate = ref->rate;
1529	break;
1530	}
1531	}
1532	mutex_unlock(lock: &chip->mutex);
1533	return rate;
1534	}
1535
1536	/**
1537	* snd_usb_endpoint_start: start an snd_usb_endpoint
1538	*
1539	* @ep: the endpoint to start
1540	*
1541	* A call to this function will increment the running count of the endpoint.
1542	* In case it is not already running, the URBs for this endpoint will be
1543	* submitted. Otherwise, this function does nothing.
1544	*
1545	* Must be balanced to calls of snd_usb_endpoint_stop().
1546	*
1547	* Returns an error if the URB submission failed, 0 in all other cases.
1548	*/
1549	int snd_usb_endpoint_start(struct snd_usb_endpoint *ep)
1550	{
1551	bool is_playback = usb_pipeout(ep->pipe);
1552	int err;
1553	unsigned int i;
1554
1555	if (atomic_read(v: &ep->chip->shutdown))
1556	return -EBADFD;
1557
1558	if (ep->sync_source)
1559	WRITE_ONCE(ep->sync_source->sync_sink, ep);
1560
1561	usb_audio_dbg(ep->chip, "Starting %s EP 0x%x (running %d)\n",
1562	ep_type_name(ep->type), ep->ep_num,
1563	atomic_read(&ep->running));
1564
1565	/* already running? */
1566	if (atomic_inc_return(v: &ep->running) != 1)
1567	return 0;
1568
1569	if (ep->clock_ref)
1570	atomic_inc(v: &ep->clock_ref->locked);
1571
1572	ep->active_mask = 0;
1573	ep->unlink_mask = 0;
1574	ep->phase = 0;
1575	ep->sample_accum = 0;
1576
1577	snd_usb_endpoint_start_quirk(ep);
1578
1579	/*
1580	* If this endpoint has a data endpoint as implicit feedback source,
1581	* don't start the urbs here. Instead, mark them all as available,
1582	* wait for the record urbs to return and queue the playback urbs
1583	* from that context.
1584	*/
1585
1586	if (!ep_state_update(ep, old: EP_STATE_STOPPED, new: EP_STATE_RUNNING))
1587	goto __error;
1588
1589	if (snd_usb_endpoint_implicit_feedback_sink(ep) &&
1590	!(ep->chip->quirk_flags & QUIRK_FLAG_PLAYBACK_FIRST)) {
1591	usb_audio_dbg(ep->chip, "No URB submission due to implicit fb sync\n");
1592	i = 0;
1593	goto fill_rest;
1594	}
1595
1596	for (i = 0; i < ep->nurbs; i++) {
1597	struct urb *urb = ep->urb[i].urb;
1598
1599	if (snd_BUG_ON(!urb))
1600	goto __error;
1601
1602	if (is_playback)
1603	err = prepare_outbound_urb(ep, ctx: urb->context, in_stream_lock: true);
1604	else
1605	err = prepare_inbound_urb(ep, urb_ctx: urb->context);
1606	if (err < 0) {
1607	/* stop filling at applptr */
1608	if (err == -EAGAIN)
1609	break;
1610	usb_audio_dbg(ep->chip,
1611	"EP 0x%x: failed to prepare urb: %d\n",
1612	ep->ep_num, err);
1613	goto __error;
1614	}
1615
1616	if (!atomic_read(v: &ep->chip->shutdown))
1617	err = usb_submit_urb(urb, GFP_ATOMIC);
1618	else
1619	err = -ENODEV;
1620	if (err < 0) {
1621	if (!atomic_read(v: &ep->chip->shutdown))
1622	usb_audio_err(ep->chip,
1623	"cannot submit urb %d, error %d: %s\n",
1624	i, err, usb_error_string(err));
1625	goto __error;
1626	}
1627	set_bit(nr: i, addr: &ep->active_mask);
1628	atomic_inc(v: &ep->submitted_urbs);
1629	}
1630
1631	if (!i) {
1632	usb_audio_dbg(ep->chip, "XRUN at starting EP 0x%x\n",
1633	ep->ep_num);
1634	goto __error;
1635	}
1636
1637	usb_audio_dbg(ep->chip, "%d URBs submitted for EP 0x%x\n",
1638	i, ep->ep_num);
1639
1640	fill_rest:
1641	/* put the remaining URBs to ready list */
1642	if (is_playback) {
1643	for (; i < ep->nurbs; i++)
1644	push_back_to_ready_list(ep, ctx: ep->urb + i);
1645	}
1646
1647	return 0;
1648
1649	__error:
1650	snd_usb_endpoint_stop(ep, keep_pending: false);
1651	return -EPIPE;
1652	}
1653
1654	/**
1655	* snd_usb_endpoint_stop: stop an snd_usb_endpoint
1656	*
1657	* @ep: the endpoint to stop (may be NULL)
1658	* @keep_pending: keep in-flight URBs
1659	*
1660	* A call to this function will decrement the running count of the endpoint.
1661	* In case the last user has requested the endpoint stop, the URBs will
1662	* actually be deactivated.
1663	*
1664	* Must be balanced to calls of snd_usb_endpoint_start().
1665	*
1666	* The caller needs to synchronize the pending stop operation via
1667	* snd_usb_endpoint_sync_pending_stop().
1668	*/
1669	void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep, bool keep_pending)
1670	{
1671	if (!ep)
1672	return;
1673
1674	usb_audio_dbg(ep->chip, "Stopping %s EP 0x%x (running %d)\n",
1675	ep_type_name(ep->type), ep->ep_num,
1676	atomic_read(&ep->running));
1677
1678	if (snd_BUG_ON(!atomic_read(&ep->running)))
1679	return;
1680
1681	if (!atomic_dec_return(v: &ep->running)) {
1682	if (ep->sync_source)
1683	WRITE_ONCE(ep->sync_source->sync_sink, NULL);
1684	stop_urbs(ep, force: false, keep_pending);
1685	if (ep->clock_ref)
1686	atomic_dec(v: &ep->clock_ref->locked);
1687
1688	if (ep->chip->quirk_flags & QUIRK_FLAG_FORCE_IFACE_RESET &&
1689	usb_pipeout(ep->pipe)) {
1690	ep->need_prepare = true;
1691	if (ep->iface_ref)
1692	ep->iface_ref->need_setup = true;
1693	}
1694	}
1695	}
1696
1697	/**
1698	* snd_usb_endpoint_release: Tear down an snd_usb_endpoint
1699	*
1700	* @ep: the endpoint to release
1701	*
1702	* This function does not care for the endpoint's running count but will tear
1703	* down all the streaming URBs immediately.
1704	*/
1705	void snd_usb_endpoint_release(struct snd_usb_endpoint *ep)
1706	{
1707	release_urbs(ep, force: true);
1708	}
1709
1710	/**
1711	* snd_usb_endpoint_free_all: Free the resources of an snd_usb_endpoint
1712	* @chip: The chip
1713	*
1714	* This free all endpoints and those resources
1715	*/
1716	void snd_usb_endpoint_free_all(struct snd_usb_audio *chip)
1717	{
1718	struct snd_usb_endpoint *ep, *en;
1719	struct snd_usb_iface_ref *ip, *in;
1720	struct snd_usb_clock_ref *cp, *cn;
1721
1722	list_for_each_entry_safe(ep, en, &chip->ep_list, list)
1723	kfree(objp: ep);
1724
1725	list_for_each_entry_safe(ip, in, &chip->iface_ref_list, list)
1726	kfree(objp: ip);
1727
1728	list_for_each_entry_safe(cp, cn, &chip->clock_ref_list, list)
1729	kfree(objp: cp);
1730	}
1731
1732	/*
1733	* snd_usb_handle_sync_urb: parse an USB sync packet
1734	*
1735	* @ep: the endpoint to handle the packet
1736	* @sender: the sending endpoint
1737	* @urb: the received packet
1738	*
1739	* This function is called from the context of an endpoint that received
1740	* the packet and is used to let another endpoint object handle the payload.
1741	*/
1742	static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
1743	struct snd_usb_endpoint *sender,
1744	const struct urb *urb)
1745	{
1746	int shift;
1747	unsigned int f;
1748	unsigned long flags;
1749
1750	snd_BUG_ON(ep == sender);
1751
1752	/*
1753	* In case the endpoint is operating in implicit feedback mode, prepare
1754	* a new outbound URB that has the same layout as the received packet
1755	* and add it to the list of pending urbs. queue_pending_output_urbs()
1756	* will take care of them later.
1757	*/
1758	if (snd_usb_endpoint_implicit_feedback_sink(ep) &&
1759	atomic_read(v: &ep->running)) {
1760
1761	/* implicit feedback case */
1762	int i, bytes = 0;
1763	struct snd_urb_ctx *in_ctx;
1764	struct snd_usb_packet_info *out_packet;
1765
1766	in_ctx = urb->context;
1767
1768	/* Count overall packet size */
1769	for (i = 0; i < in_ctx->packets; i++)
1770	if (urb->iso_frame_desc[i].status == 0)
1771	bytes += urb->iso_frame_desc[i].actual_length;
1772
1773	/*
1774	* skip empty packets. At least M-Audio's Fast Track Ultra stops
1775	* streaming once it received a 0-byte OUT URB
1776	*/
1777	if (bytes == 0)
1778	return;
1779
1780	spin_lock_irqsave(&ep->lock, flags);
1781	if (ep->next_packet_queued >= ARRAY_SIZE(ep->next_packet)) {
1782	spin_unlock_irqrestore(lock: &ep->lock, flags);
1783	usb_audio_err(ep->chip,
1784	"next package FIFO overflow EP 0x%x\n",
1785	ep->ep_num);
1786	notify_xrun(ep);
1787	return;
1788	}
1789
1790	out_packet = next_packet_fifo_enqueue(ep);
1791
1792	/*
1793	* Iterate through the inbound packet and prepare the lengths
1794	* for the output packet. The OUT packet we are about to send
1795	* will have the same amount of payload bytes per stride as the
1796	* IN packet we just received. Since the actual size is scaled
1797	* by the stride, use the sender stride to calculate the length
1798	* in case the number of channels differ between the implicitly
1799	* fed-back endpoint and the synchronizing endpoint.
1800	*/
1801
1802	out_packet->packets = in_ctx->packets;
1803	for (i = 0; i < in_ctx->packets; i++) {
1804	if (urb->iso_frame_desc[i].status == 0)
1805	out_packet->packet_size[i] =
1806	urb->iso_frame_desc[i].actual_length / sender->stride;
1807	else
1808	out_packet->packet_size[i] = 0;
1809	}
1810
1811	spin_unlock_irqrestore(lock: &ep->lock, flags);
1812	snd_usb_queue_pending_output_urbs(ep, in_stream_lock: false);
1813
1814	return;
1815	}
1816
1817	/*
1818	* process after playback sync complete
1819	*
1820	* Full speed devices report feedback values in 10.14 format as samples
1821	* per frame, high speed devices in 16.16 format as samples per
1822	* microframe.
1823	*
1824	* Because the Audio Class 1 spec was written before USB 2.0, many high
1825	* speed devices use a wrong interpretation, some others use an
1826	* entirely different format.
1827	*
1828	* Therefore, we cannot predict what format any particular device uses
1829	* and must detect it automatically.
1830	*/
1831
1832	if (urb->iso_frame_desc[0].status != 0 ||
1833	urb->iso_frame_desc[0].actual_length < 3)
1834	return;
1835
1836	f = le32_to_cpup(p: urb->transfer_buffer);
1837	if (urb->iso_frame_desc[0].actual_length == 3)
1838	f &= 0x00ffffff;
1839	else
1840	f &= 0x0fffffff;
1841
1842	if (f == 0)
1843	return;
1844
1845	if (unlikely(sender->tenor_fb_quirk)) {
1846	/*
1847	* Devices based on Tenor 8802 chipsets (TEAC UD-H01
1848	* and others) sometimes change the feedback value
1849	* by +/- 0x1.0000.
1850	*/
1851	if (f < ep->freqn - 0x8000)
1852	f += 0xf000;
1853	else if (f > ep->freqn + 0x8000)
1854	f -= 0xf000;
1855	} else if (unlikely(ep->freqshift == INT_MIN)) {
1856	/*
1857	* The first time we see a feedback value, determine its format
1858	* by shifting it left or right until it matches the nominal
1859	* frequency value. This assumes that the feedback does not
1860	* differ from the nominal value more than +50% or -25%.
1861	*/
1862	shift = 0;
1863	while (f < ep->freqn - ep->freqn / 4) {
1864	f <<= 1;
1865	shift++;
1866	}
1867	while (f > ep->freqn + ep->freqn / 2) {
1868	f >>= 1;
1869	shift--;
1870	}
1871	ep->freqshift = shift;
1872	} else if (ep->freqshift >= 0)
1873	f <<= ep->freqshift;
1874	else
1875	f >>= -ep->freqshift;
1876
1877	if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1878	/*
1879	* If the frequency looks valid, set it.
1880	* This value is referred to in prepare_playback_urb().
1881	*/
1882	spin_lock_irqsave(&ep->lock, flags);
1883	ep->freqm = f;
1884	spin_unlock_irqrestore(lock: &ep->lock, flags);
1885	} else {
1886	/*
1887	* Out of range; maybe the shift value is wrong.
1888	* Reset it so that we autodetect again the next time.
1889	*/
1890	ep->freqshift = INT_MIN;
1891	}
1892	}
1893
1894