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