endpoint.c 41 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
Daniel Mack's avatar
Daniel Mack committed
2
3
4
/*
 */

5
6
#include <linux/gfp.h>
#include <linux/init.h>
7
#include <linux/ratelimit.h>
8
9
#include <linux/usb.h>
#include <linux/usb/audio.h>
10
#include <linux/slab.h>
11
12
13

#include <sound/core.h>
#include <sound/pcm.h>
14
#include <sound/pcm_params.h>
15
16
17
18
19
20

#include "usbaudio.h"
#include "helper.h"
#include "card.h"
#include "endpoint.h"
#include "pcm.h"
21
#include "clock.h"
22
#include "quirks.h"
23

24
#define EP_FLAG_RUNNING		1
25
#define EP_FLAG_STOPPING	2
26

27
28
29
30
31
/*
 * snd_usb_endpoint is a model that abstracts everything related to an
 * USB endpoint and its streaming.
 *
 * There are functions to activate and deactivate the streaming URBs and
32
 * optional callbacks to let the pcm logic handle the actual content of the
33
34
35
 * packets for playback and record. Thus, the bus streaming and the audio
 * handlers are fully decoupled.
 *
36
 * There are two different types of endpoints in audio applications.
37
38
39
40
 *
 * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
 * inbound and outbound traffic.
 *
41
42
43
 * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
 * expect the payload to carry Q10.14 / Q16.16 formatted sync information
 * (3 or 4 bytes).
44
 *
45
46
 * Each endpoint has to be configured prior to being used by calling
 * snd_usb_endpoint_set_params().
47
48
49
50
 *
 * The model incorporates a reference counting, so that multiple users
 * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
 * only the first user will effectively start the URBs, and only the last
51
 * one to stop it will tear the URBs down again.
52
53
 */

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/*
 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
 * this will overflow at approx 524 kHz
 */
static inline unsigned get_usb_full_speed_rate(unsigned int rate)
{
	return ((rate << 13) + 62) / 125;
}

/*
 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
 * this will overflow at approx 4 MHz
 */
static inline unsigned get_usb_high_speed_rate(unsigned int rate)
{
	return ((rate << 10) + 62) / 125;
}

/*
 * release a urb data
 */
static void release_urb_ctx(struct snd_urb_ctx *u)
{
77
78
79
80
81
82
	if (u->buffer_size)
		usb_free_coherent(u->ep->chip->dev, u->buffer_size,
				  u->urb->transfer_buffer,
				  u->urb->transfer_dma);
	usb_free_urb(u->urb);
	u->urb = NULL;
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
}

static const char *usb_error_string(int err)
{
	switch (err) {
	case -ENODEV:
		return "no device";
	case -ENOENT:
		return "endpoint not enabled";
	case -EPIPE:
		return "endpoint stalled";
	case -ENOSPC:
		return "not enough bandwidth";
	case -ESHUTDOWN:
		return "device disabled";
	case -EHOSTUNREACH:
		return "device suspended";
	case -EINVAL:
	case -EAGAIN:
	case -EFBIG:
	case -EMSGSIZE:
		return "internal error";
	default:
		return "unknown error";
	}
}

110
111
112
/**
 * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
 *
113
 * @ep: The snd_usb_endpoint
114
115
116
117
 *
 * Determine whether an endpoint is driven by an implicit feedback
 * data endpoint source.
 */
118
int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep)
119
{
120
	return  ep->implicit_fb_sync && usb_pipeout(ep->pipe);
121
122
}

123
/*
124
125
 * Return the number of samples to be sent in the next packet
 * for streaming based on information derived from sync endpoints
126
 *
127
128
 * This won't be used for implicit feedback which takes the packet size
 * returned from the sync source
129
 */
130
static int slave_next_packet_size(struct snd_usb_endpoint *ep)
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
{
	unsigned long flags;
	int ret;

	if (ep->fill_max)
		return ep->maxframesize;

	spin_lock_irqsave(&ep->lock, flags);
	ep->phase = (ep->phase & 0xffff)
		+ (ep->freqm << ep->datainterval);
	ret = min(ep->phase >> 16, ep->maxframesize);
	spin_unlock_irqrestore(&ep->lock, flags);

	return ret;
}

147
/*
148
149
 * Return the number of samples to be sent in the next packet
 * for adaptive and synchronous endpoints
150
 */
151
static int next_packet_size(struct snd_usb_endpoint *ep)
152
153
154
155
156
157
158
{
	int ret;

	if (ep->fill_max)
		return ep->maxframesize;

	ep->sample_accum += ep->sample_rem;
159
160
161
	if (ep->sample_accum >= ep->pps) {
		ep->sample_accum -= ep->pps;
		ret = ep->packsize[1];
162
	} else {
163
		ret = ep->packsize[0];
164
165
166
167
168
	}

	return ret;
}

169
170
171
172
173
174
175
176
177
/*
 * snd_usb_endpoint_next_packet_size: Return the number of samples to be sent
 * in the next packet
 */
int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep,
				      struct snd_urb_ctx *ctx, int idx)
{
	if (ctx->packet_size[idx])
		return ctx->packet_size[idx];
178
	else if (ep->sync_source)
179
180
181
182
183
		return slave_next_packet_size(ep);
	else
		return next_packet_size(ep);
}

184
185
186
187
188
189
190
191
192
193
static void call_retire_callback(struct snd_usb_endpoint *ep,
				 struct urb *urb)
{
	struct snd_usb_substream *data_subs;

	data_subs = READ_ONCE(ep->data_subs);
	if (data_subs && ep->retire_data_urb)
		ep->retire_data_urb(data_subs, urb);
}

194
195
196
static void retire_outbound_urb(struct snd_usb_endpoint *ep,
				struct snd_urb_ctx *urb_ctx)
{
197
	call_retire_callback(ep, urb_ctx->urb);
198
199
}

200
201
202
203
static void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
				    struct snd_usb_endpoint *sender,
				    const struct urb *urb);

204
205
206
207
static void retire_inbound_urb(struct snd_usb_endpoint *ep,
			       struct snd_urb_ctx *urb_ctx)
{
	struct urb *urb = urb_ctx->urb;
208
	struct snd_usb_endpoint *sync_sink;
209

210
211
212
213
214
	if (unlikely(ep->skip_packets > 0)) {
		ep->skip_packets--;
		return;
	}

215
216
217
	sync_sink = READ_ONCE(ep->sync_sink);
	if (sync_sink)
		snd_usb_handle_sync_urb(sync_sink, ep, urb);
218

219
	call_retire_callback(ep, urb);
220
221
}

222
223
224
225
226
static void prepare_silent_urb(struct snd_usb_endpoint *ep,
			       struct snd_urb_ctx *ctx)
{
	struct urb *urb = ctx->urb;
	unsigned int offs = 0;
227
228
	unsigned int extra = 0;
	__le32 packet_length;
229
230
	int i;

231
232
233
234
	/* For tx_length_quirk, put packet length at start of packet */
	if (ep->chip->tx_length_quirk)
		extra = sizeof(packet_length);

235
	for (i = 0; i < ctx->packets; ++i) {
236
237
		unsigned int offset;
		unsigned int length;
238
239
		int counts;

240
		counts = snd_usb_endpoint_next_packet_size(ep, ctx, i);
241
242
243
244
245
246
247
248
249
250
251
		length = counts * ep->stride; /* number of silent bytes */
		offset = offs * ep->stride + extra * i;
		urb->iso_frame_desc[i].offset = offset;
		urb->iso_frame_desc[i].length = length + extra;
		if (extra) {
			packet_length = cpu_to_le32(length);
			memcpy(urb->transfer_buffer + offset,
			       &packet_length, sizeof(packet_length));
		}
		memset(urb->transfer_buffer + offset + extra,
		       ep->silence_value, length);
252
253
254
255
		offs += counts;
	}

	urb->number_of_packets = ctx->packets;
256
	urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra;
257
258
}

259
260
261
262
263
264
265
266
/*
 * Prepare a PLAYBACK urb for submission to the bus.
 */
static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
				 struct snd_urb_ctx *ctx)
{
	struct urb *urb = ctx->urb;
	unsigned char *cp = urb->transfer_buffer;
267
	struct snd_usb_substream *data_subs;
268
269
270
271
272

	urb->dev = ep->chip->dev; /* we need to set this at each time */

	switch (ep->type) {
	case SND_USB_ENDPOINT_TYPE_DATA:
273
274
275
276
		data_subs = READ_ONCE(ep->data_subs);
		if (data_subs && ep->prepare_data_urb)
			ep->prepare_data_urb(data_subs, urb);
		else /* no data provider, so send silence */
277
			prepare_silent_urb(ep, ctx);
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
		break;

	case SND_USB_ENDPOINT_TYPE_SYNC:
		if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
			/*
			 * fill the length and offset of each urb descriptor.
			 * the fixed 12.13 frequency is passed as 16.16 through the pipe.
			 */
			urb->iso_frame_desc[0].length = 4;
			urb->iso_frame_desc[0].offset = 0;
			cp[0] = ep->freqn;
			cp[1] = ep->freqn >> 8;
			cp[2] = ep->freqn >> 16;
			cp[3] = ep->freqn >> 24;
		} else {
			/*
			 * fill the length and offset of each urb descriptor.
			 * the fixed 10.14 frequency is passed through the pipe.
			 */
			urb->iso_frame_desc[0].length = 3;
			urb->iso_frame_desc[0].offset = 0;
			cp[0] = ep->freqn >> 2;
			cp[1] = ep->freqn >> 10;
			cp[2] = ep->freqn >> 18;
		}

		break;
	}
}

/*
 * Prepare a CAPTURE or SYNC urb for submission to the bus.
 */
static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
				       struct snd_urb_ctx *urb_ctx)
{
	int i, offs;
	struct urb *urb = urb_ctx->urb;

	urb->dev = ep->chip->dev; /* we need to set this at each time */

	switch (ep->type) {
	case SND_USB_ENDPOINT_TYPE_DATA:
		offs = 0;
		for (i = 0; i < urb_ctx->packets; i++) {
			urb->iso_frame_desc[i].offset = offs;
			urb->iso_frame_desc[i].length = ep->curpacksize;
			offs += ep->curpacksize;
		}

		urb->transfer_buffer_length = offs;
		urb->number_of_packets = urb_ctx->packets;
		break;

	case SND_USB_ENDPOINT_TYPE_SYNC:
		urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
		urb->iso_frame_desc[0].offset = 0;
		break;
	}
}

339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
/* notify an error as XRUN to the assigned PCM data substream */
static void notify_xrun(struct snd_usb_endpoint *ep)
{
	struct snd_usb_substream *data_subs;

	data_subs = READ_ONCE(ep->data_subs);
	if (data_subs && data_subs->pcm_substream)
		snd_pcm_stop_xrun(data_subs->pcm_substream);
}

static struct snd_usb_packet_info *
next_packet_fifo_enqueue(struct snd_usb_endpoint *ep)
{
	struct snd_usb_packet_info *p;

	p = ep->next_packet + (ep->next_packet_head + ep->next_packet_queued) %
		ARRAY_SIZE(ep->next_packet);
	ep->next_packet_queued++;
	return p;
}

static struct snd_usb_packet_info *
next_packet_fifo_dequeue(struct snd_usb_endpoint *ep)
{
	struct snd_usb_packet_info *p;

	p = ep->next_packet + ep->next_packet_head;
	ep->next_packet_head++;
	ep->next_packet_head %= ARRAY_SIZE(ep->next_packet);
	ep->next_packet_queued--;
	return p;
}

372
/*
373
 * Send output urbs that have been prepared previously. URBs are dequeued
374
 * from ep->ready_playback_urbs and in case there aren't any available
375
376
377
 * or there are no packets that have been prepared, this function does
 * nothing.
 *
378
379
380
 * The reason why the functionality of sending and preparing URBs is separated
 * is that host controllers don't guarantee the order in which they return
 * inbound and outbound packets to their submitters.
381
382
 *
 * This function is only used for implicit feedback endpoints. For endpoints
383
384
 * driven by dedicated sync endpoints, URBs are immediately re-submitted
 * from their completion handler.
385
 */
386
387
388
389
390
static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
{
	while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {

		unsigned long flags;
391
		struct snd_usb_packet_info *packet;
392
393
394
395
		struct snd_urb_ctx *ctx = NULL;
		int err, i;

		spin_lock_irqsave(&ep->lock, flags);
396
397
		if (ep->next_packet_queued > 0 &&
		    !list_empty(&ep->ready_playback_urbs)) {
398
			/* take URB out of FIFO */
399
			ctx = list_first_entry(&ep->ready_playback_urbs,
400
					       struct snd_urb_ctx, ready_list);
401
402
403
			list_del_init(&ctx->ready_list);

			packet = next_packet_fifo_dequeue(ep);
404
405
406
407
408
409
410
411
412
413
		}
		spin_unlock_irqrestore(&ep->lock, flags);

		if (ctx == NULL)
			return;

		/* copy over the length information */
		for (i = 0; i < packet->packets; i++)
			ctx->packet_size[i] = packet->packet_size[i];

414
		/* call the data handler to fill in playback data */
415
416
417
		prepare_outbound_urb(ep, ctx);

		err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
418
		if (err < 0) {
419
			usb_audio_err(ep->chip,
420
421
				      "Unable to submit urb #%d: %d at %s\n",
				      ctx->index, err, __func__);
422
423
424
425
426
			notify_xrun(ep);
			return;
		}

		set_bit(ctx->index, &ep->active_mask);
427
428
429
430
431
432
433
434
435
436
	}
}

/*
 * complete callback for urbs
 */
static void snd_complete_urb(struct urb *urb)
{
	struct snd_urb_ctx *ctx = urb->context;
	struct snd_usb_endpoint *ep = ctx->ep;
437
	unsigned long flags;
438
439
440
441
442
	int err;

	if (unlikely(urb->status == -ENOENT ||		/* unlinked */
		     urb->status == -ENODEV ||		/* device removed */
		     urb->status == -ECONNRESET ||	/* unlinked */
443
444
445
446
		     urb->status == -ESHUTDOWN))	/* device disabled */
		goto exit_clear;
	/* device disconnected */
	if (unlikely(atomic_read(&ep->chip->shutdown)))
447
448
		goto exit_clear;

449
450
451
	if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
		goto exit_clear;

452
453
454
455
456
457
	if (usb_pipeout(ep->pipe)) {
		retire_outbound_urb(ep, ctx);
		/* can be stopped during retire callback */
		if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
			goto exit_clear;

458
		if (snd_usb_endpoint_implicit_feedback_sink(ep)) {
459
460
			spin_lock_irqsave(&ep->lock, flags);
			list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
461
			clear_bit(ctx->index, &ep->active_mask);
462
463
			spin_unlock_irqrestore(&ep->lock, flags);
			queue_pending_output_urbs(ep);
464
			return;
465
466
467
		}

		prepare_outbound_urb(ep, ctx);
468
469
470
		/* can be stopped during prepare callback */
		if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
			goto exit_clear;
471
472
473
474
475
476
477
478
479
480
481
482
483
	} else {
		retire_inbound_urb(ep, ctx);
		/* can be stopped during retire callback */
		if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
			goto exit_clear;

		prepare_inbound_urb(ep, ctx);
	}

	err = usb_submit_urb(urb, GFP_ATOMIC);
	if (err == 0)
		return;

484
	usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
485
	notify_xrun(ep);
486
487
488
489
490

exit_clear:
	clear_bit(ctx->index, &ep->active_mask);
}

491
/*
492
 * Get the existing endpoint object corresponding EP
493
494
495
 * Returns NULL if not present.
 */
struct snd_usb_endpoint *
496
snd_usb_get_endpoint(struct snd_usb_audio *chip, int ep_num)
497
498
499
500
{
	struct snd_usb_endpoint *ep;

	list_for_each_entry(ep, &chip->ep_list, list) {
501
		if (ep->ep_num == ep_num)
502
503
			return ep;
	}
504

505
506
507
	return NULL;
}

508
509
510
#define ep_type_name(type) \
	(type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync")

511
/**
512
 * snd_usb_add_endpoint: Add an endpoint to an USB audio chip
513
514
515
516
517
518
 *
 * @chip: The chip
 * @ep_num: The number of the endpoint to use
 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
 *
 * If the requested endpoint has not been added to the given chip before,
519
520
521
 * a new instance is created.
 *
 * Returns zero on success or a negative error code.
522
523
524
 *
 * New endpoints will be added to chip->ep_list and must be freed by
 * calling snd_usb_endpoint_free().
525
526
527
 *
 * For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that
 * bNumEndpoints > 1 beforehand.
528
 */
529
int snd_usb_add_endpoint(struct snd_usb_audio *chip, int ep_num, int type)
530
531
{
	struct snd_usb_endpoint *ep;
532
	bool is_playback;
533

534
535
536
	ep = snd_usb_get_endpoint(chip, ep_num);
	if (ep)
		return 0;
537

538
	usb_audio_dbg(chip, "Creating new %s endpoint #%x\n",
539
540
		      ep_type_name(type),
		      ep_num);
541
542
	ep = kzalloc(sizeof(*ep), GFP_KERNEL);
	if (!ep)
543
		return -ENOMEM;
544
545
546
547
548
549
550

	ep->chip = chip;
	spin_lock_init(&ep->lock);
	ep->type = type;
	ep->ep_num = ep_num;
	INIT_LIST_HEAD(&ep->ready_playback_urbs);

551
552
	is_playback = ((ep_num & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT);
	ep_num &= USB_ENDPOINT_NUMBER_MASK;
553
554
555
556
557
	if (is_playback)
		ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
	else
		ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);

558
559
560
561
562
	list_add_tail(&ep->list, &chip->ep_list);
	return 0;
}

/* Set up syncinterval and maxsyncsize for a sync EP */
563
564
static void endpoint_set_syncinterval(struct snd_usb_audio *chip,
				      struct snd_usb_endpoint *ep)
565
{
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
	struct usb_host_interface *alts;
	struct usb_endpoint_descriptor *desc;

	alts = snd_usb_get_host_interface(chip, ep->iface, ep->altsetting);
	if (!alts)
		return;

	desc = get_endpoint(alts, ep->ep_idx);
	if (desc->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
	    desc->bRefresh >= 1 && desc->bRefresh <= 9)
		ep->syncinterval = desc->bRefresh;
	else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
		ep->syncinterval = 1;
	else if (desc->bInterval >= 1 && desc->bInterval <= 16)
		ep->syncinterval = desc->bInterval - 1;
	else
		ep->syncinterval = 3;

	ep->syncmaxsize = le16_to_cpu(desc->wMaxPacketSize);
}

static bool endpoint_compatible(struct snd_usb_endpoint *ep,
				const struct audioformat *fp,
				const struct snd_pcm_hw_params *params)
{
	if (!ep->opened)
		return false;
	if (ep->cur_audiofmt != fp)
		return false;
	if (ep->cur_rate != params_rate(params) ||
	    ep->cur_format != params_format(params) ||
	    ep->cur_period_frames != params_period_size(params) ||
	    ep->cur_buffer_periods != params_periods(params))
		return false;
	return true;
}

/*
 * Check whether the given fp and hw params are compatbile with the current
 * setup of the target EP for implicit feedback sync
 */
bool snd_usb_endpoint_compatible(struct snd_usb_audio *chip,
				 struct snd_usb_endpoint *ep,
				 const struct audioformat *fp,
				 const struct snd_pcm_hw_params *params)
{
	bool ret;

	mutex_lock(&chip->mutex);
	ret = endpoint_compatible(ep, fp, params);
	mutex_unlock(&chip->mutex);
	return ret;
}

/*
 * snd_usb_endpoint_open: Open the endpoint
 *
 * Called from hw_params to assign the endpoint to the substream.
 * It's reference-counted, and only the first opener is allowed to set up
 * arbitrary parameters.  The later opener must be compatible with the
 * former opened parameters.
 * The endpoint needs to be closed via snd_usb_endpoint_close() later.
 *
 * Note that this function doesn't configure the endpoint.  The substream
 * needs to set it up later via snd_usb_endpoint_configure().
 */
struct snd_usb_endpoint *
snd_usb_endpoint_open(struct snd_usb_audio *chip,
634
		      const struct audioformat *fp,
635
636
637
638
639
		      const struct snd_pcm_hw_params *params,
		      bool is_sync_ep)
{
	struct snd_usb_endpoint *ep;
	int ep_num = is_sync_ep ? fp->sync_ep : fp->endpoint;
640

641
642
643
644
645
	mutex_lock(&chip->mutex);
	ep = snd_usb_get_endpoint(chip, ep_num);
	if (!ep) {
		usb_audio_err(chip, "Cannot find EP 0x%x to open\n", ep_num);
		goto unlock;
646
	}
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710

	if (!ep->opened) {
		if (is_sync_ep) {
			ep->iface = fp->sync_iface;
			ep->altsetting = fp->sync_altsetting;
			ep->ep_idx = fp->sync_ep_idx;
		} else {
			ep->iface = fp->iface;
			ep->altsetting = fp->altsetting;
			ep->ep_idx = 0;
		}
		usb_audio_dbg(chip, "Open EP 0x%x, iface=%d:%d, idx=%d\n",
			      ep_num, ep->iface, ep->altsetting, ep->ep_idx);

		ep->cur_audiofmt = fp;
		ep->cur_channels = fp->channels;
		ep->cur_rate = params_rate(params);
		ep->cur_format = params_format(params);
		ep->cur_frame_bytes = snd_pcm_format_physical_width(ep->cur_format) *
			ep->cur_channels / 8;
		ep->cur_period_frames = params_period_size(params);
		ep->cur_period_bytes = ep->cur_period_frames * ep->cur_frame_bytes;
		ep->cur_buffer_periods = params_periods(params);

		if (ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
			endpoint_set_syncinterval(chip, ep);

		ep->implicit_fb_sync = fp->implicit_fb;
		ep->need_setup = true;

		usb_audio_dbg(chip, "  channels=%d, rate=%d, format=%s, period_bytes=%d, periods=%d, implicit_fb=%d\n",
			      ep->cur_channels, ep->cur_rate,
			      snd_pcm_format_name(ep->cur_format),
			      ep->cur_period_bytes, ep->cur_buffer_periods,
			      ep->implicit_fb_sync);

	} else {
		if (!endpoint_compatible(ep, fp, params)) {
			usb_audio_err(chip, "Incompatible EP setup for 0x%x\n",
				      ep_num);
			ep = NULL;
			goto unlock;
		}

		usb_audio_dbg(chip, "Reopened EP 0x%x (count %d)\n",
			      ep_num, ep->opened);
	}

	ep->opened++;

 unlock:
	mutex_unlock(&chip->mutex);
	return ep;
}

/*
 * snd_usb_endpoint_set_sync: Link data and sync endpoints
 *
 * Pass NULL to sync_ep to unlink again
 */
void snd_usb_endpoint_set_sync(struct snd_usb_audio *chip,
			       struct snd_usb_endpoint *data_ep,
			       struct snd_usb_endpoint *sync_ep)
{
711
	data_ep->sync_source = sync_ep;
712
713
}

714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
/*
 * Set data endpoint callbacks and the assigned data stream
 *
 * Called at PCM trigger and cleanups.
 * Pass NULL to deactivate each callback.
 */
void snd_usb_endpoint_set_callback(struct snd_usb_endpoint *ep,
				   void (*prepare)(struct snd_usb_substream *subs,
						   struct urb *urb),
				   void (*retire)(struct snd_usb_substream *subs,
						  struct urb *urb),
				   struct snd_usb_substream *data_subs)
{
	ep->prepare_data_urb = prepare;
	ep->retire_data_urb = retire;
	WRITE_ONCE(ep->data_subs, data_subs);
}

732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
static int endpoint_set_interface(struct snd_usb_audio *chip,
				  struct snd_usb_endpoint *ep,
				  bool set)
{
	int altset = set ? ep->altsetting : 0;
	int err;

	usb_audio_dbg(chip, "Setting usb interface %d:%d for EP 0x%x\n",
		      ep->iface, altset, ep->ep_num);
	err = usb_set_interface(chip->dev, ep->iface, altset);
	if (err < 0) {
		usb_audio_err(chip, "%d:%d: usb_set_interface failed (%d)\n",
			      ep->iface, altset, err);
		return err;
	}

	snd_usb_set_interface_quirk(chip);
	return 0;
}

/*
 * snd_usb_endpoint_close: Close the endpoint
 *
 * Unreference the already opened endpoint via snd_usb_endpoint_open().
 */
void snd_usb_endpoint_close(struct snd_usb_audio *chip,
			    struct snd_usb_endpoint *ep)
{
	mutex_lock(&chip->mutex);
	usb_audio_dbg(chip, "Closing EP 0x%x (count %d)\n",
		      ep->ep_num, ep->opened);
	if (!--ep->opened) {
		endpoint_set_interface(chip, ep, false);
		ep->iface = -1;
		ep->altsetting = 0;
		ep->cur_audiofmt = NULL;
		ep->cur_rate = 0;
		usb_audio_dbg(chip, "EP 0x%x closed\n", ep->ep_num);
	}
	mutex_unlock(&chip->mutex);
}

/* Prepare for suspening EP, called from the main suspend handler */
void snd_usb_endpoint_suspend(struct snd_usb_endpoint *ep)
{
	ep->need_setup = true;
}

780
781
782
783
784
785
786
787
/*
 *  wait until all urbs are processed.
 */
static int wait_clear_urbs(struct snd_usb_endpoint *ep)
{
	unsigned long end_time = jiffies + msecs_to_jiffies(1000);
	int alive;

788
789
790
	if (!test_bit(EP_FLAG_STOPPING, &ep->flags))
		return 0;

791
	do {
792
		alive = bitmap_weight(&ep->active_mask, ep->nurbs);
793
794
795
796
797
798
799
		if (!alive)
			break;

		schedule_timeout_uninterruptible(1);
	} while (time_before(jiffies, end_time));

	if (alive)
800
801
802
		usb_audio_err(ep->chip,
			"timeout: still %d active urbs on EP #%x\n",
			alive, ep->ep_num);
803
	clear_bit(EP_FLAG_STOPPING, &ep->flags);
804

805
	ep->sync_sink = NULL;
806
	snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL);
807

808
809
810
	return 0;
}

811
812
813
814
815
/* sync the pending stop operation;
 * this function itself doesn't trigger the stop operation
 */
void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep)
{
816
	if (ep)
817
818
819
		wait_clear_urbs(ep);
}

820
/*
821
822
823
824
 * Stop and unlink active urbs.
 *
 * This function checks and clears EP_FLAG_RUNNING state.
 * When @wait_sync is set, it waits until all pending URBs are killed.
825
 */
826
827
static int stop_and_unlink_urbs(struct snd_usb_endpoint *ep, bool force,
				bool wait_sync)
828
829
830
{
	unsigned int i;

831
	if (!force && atomic_read(&ep->chip->shutdown)) /* to be sure... */
832
833
		return -EBADFD;

834
835
836
837
838
	if (atomic_read(&ep->running))
		return -EBUSY;

	if (!test_and_clear_bit(EP_FLAG_RUNNING, &ep->flags))
		goto out;
839

840
	set_bit(EP_FLAG_STOPPING, &ep->flags);
841
	INIT_LIST_HEAD(&ep->ready_playback_urbs);
842
843
	ep->next_packet_head = 0;
	ep->next_packet_queued = 0;
844
845
846
847
848

	for (i = 0; i < ep->nurbs; i++) {
		if (test_bit(i, &ep->active_mask)) {
			if (!test_and_set_bit(i, &ep->unlink_mask)) {
				struct urb *u = ep->urb[i].urb;
849
				usb_unlink_urb(u);
850
851
852
853
			}
		}
	}

854
855
856
 out:
	if (wait_sync)
		return wait_clear_urbs(ep);
857
858
859
860
861
862
863
864
865
866
867
	return 0;
}

/*
 * release an endpoint's urbs
 */
static void release_urbs(struct snd_usb_endpoint *ep, int force)
{
	int i;

	/* route incoming urbs to nirvana */
868
	snd_usb_endpoint_set_callback(ep, NULL, NULL, NULL);
869
870

	/* stop urbs */
871
	stop_and_unlink_urbs(ep, force, true);
872
873
874
875

	for (i = 0; i < ep->nurbs; i++)
		release_urb_ctx(&ep->urb[i]);

876
877
	usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
			  ep->syncbuf, ep->sync_dma);
878
879
880
881
882

	ep->syncbuf = NULL;
	ep->nurbs = 0;
}

883
884
885
/*
 * configure a data endpoint
 */
886
static int data_ep_set_params(struct snd_usb_endpoint *ep)
887
{
888
	struct snd_usb_audio *chip = ep->chip;
889
890
891
	unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
	unsigned int max_packs_per_period, urbs_per_period, urb_packs;
	unsigned int max_urbs, i;
892
893
894
	const struct audioformat *fmt = ep->cur_audiofmt;
	int frame_bits = ep->cur_frame_bytes * 8;
	int tx_length_quirk = (chip->tx_length_quirk &&
895
			       usb_pipeout(ep->pipe));
896

897
898
899
900
	usb_audio_dbg(chip, "Setting params for data EP 0x%x, pipe 0x%x\n",
		      ep->ep_num, ep->pipe);

	if (ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
901
902
903
904
905
		/*
		 * When operating in DSD DOP mode, the size of a sample frame
		 * in hardware differs from the actual physical format width
		 * because we need to make room for the DOP markers.
		 */
906
		frame_bits += ep->cur_channels << 3;
907
908
	}

909
910
	ep->datainterval = fmt->datainterval;
	ep->stride = frame_bits >> 3;
911

912
	switch (ep->cur_format) {
913
914
915
916
917
918
919
920
921
922
923
924
925
	case SNDRV_PCM_FORMAT_U8:
		ep->silence_value = 0x80;
		break;
	case SNDRV_PCM_FORMAT_DSD_U8:
	case SNDRV_PCM_FORMAT_DSD_U16_LE:
	case SNDRV_PCM_FORMAT_DSD_U32_LE:
	case SNDRV_PCM_FORMAT_DSD_U16_BE:
	case SNDRV_PCM_FORMAT_DSD_U32_BE:
		ep->silence_value = 0x69;
		break;
	default:
		ep->silence_value = 0;
	}
926

927
928
	/* assume max. frequency is 50% higher than nominal */
	ep->freqmax = ep->freqn + (ep->freqn >> 1);
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
	/* Round up freqmax to nearest integer in order to calculate maximum
	 * packet size, which must represent a whole number of frames.
	 * This is accomplished by adding 0x0.ffff before converting the
	 * Q16.16 format into integer.
	 * In order to accurately calculate the maximum packet size when
	 * the data interval is more than 1 (i.e. ep->datainterval > 0),
	 * multiply by the data interval prior to rounding. For instance,
	 * a freqmax of 41 kHz will result in a max packet size of 6 (5.125)
	 * frames with a data interval of 1, but 11 (10.25) frames with a
	 * data interval of 2.
	 * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
	 * maximum datainterval value of 3, at USB full speed, higher for
	 * USB high speed, noting that ep->freqmax is in units of
	 * frames per packet in Q16.16 format.)
	 */
	maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
			 (frame_bits >> 3);
946
947
	if (tx_length_quirk)
		maxsize += sizeof(__le32); /* Space for length descriptor */
948
949
	/* but wMaxPacketSize might reduce this */
	if (ep->maxpacksize && ep->maxpacksize < maxsize) {
950
		/* whatever fits into a max. size packet */
951
952
953
954
955
956
		unsigned int data_maxsize = maxsize = ep->maxpacksize;

		if (tx_length_quirk)
			/* Need to remove the length descriptor to calc freq */
			data_maxsize -= sizeof(__le32);
		ep->freqmax = (data_maxsize / (frame_bits >> 3))
957
958
959
960
961
962
963
964
				<< (16 - ep->datainterval);
	}

	if (ep->fill_max)
		ep->curpacksize = ep->maxpacksize;
	else
		ep->curpacksize = maxsize;

965
	if (snd_usb_get_speed(chip->dev) != USB_SPEED_FULL) {
966
		packs_per_ms = 8 >> ep->datainterval;
967
		max_packs_per_urb = MAX_PACKS_HS;
968
	} else {
969
970
		packs_per_ms = 1;
		max_packs_per_urb = MAX_PACKS;
971
	}
972
	if (ep->sync_source && !ep->implicit_fb_sync)
973
		max_packs_per_urb = min(max_packs_per_urb,
974
					1U << ep->sync_source->syncinterval);
975
976
977
978
979
980
981
982
983
984
	max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);

	/*
	 * Capture endpoints need to use small URBs because there's no way
	 * to tell in advance where the next period will end, and we don't
	 * want the next URB to complete much after the period ends.
	 *
	 * Playback endpoints with implicit sync much use the same parameters
	 * as their corresponding capture endpoint.
	 */
985
	if (usb_pipein(ep->pipe) || ep->implicit_fb_sync) {
986

987
988
989
990
991
992
993
		urb_packs = packs_per_ms;
		/*
		 * Wireless devices can poll at a max rate of once per 4ms.
		 * For dataintervals less than 5, increase the packet count to
		 * allow the host controller to use bursting to fill in the
		 * gaps.
		 */
994
		if (snd_usb_get_speed(chip->dev) == USB_SPEED_WIRELESS) {
995
996
997
998
999
1000
			int interval = ep->datainterval;
			while (interval < 5) {
				urb_packs <<= 1;
				++interval;
			}
		}
For faster browsing, not all history is shown. View entire blame