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 "quirks.h"
22
23 #define EP_FLAG_RUNNING 1
24 #define EP_FLAG_STOPPING 2
25
26 /*
27 * snd_usb_endpoint is a model that abstracts everything related to an
28 * USB endpoint and its streaming.
29 *
30 * There are functions to activate and deactivate the streaming URBs and
31 * optional callbacks to let the pcm logic handle the actual content of the
32 * packets for playback and record. Thus, the bus streaming and the audio
33 * handlers are fully decoupled.
34 *
35 * There are two different types of endpoints in audio applications.
36 *
37 * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
38 * inbound and outbound traffic.
39 *
40 * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
41 * expect the payload to carry Q10.14 / Q16.16 formatted sync information
42 * (3 or 4 bytes).
43 *
44 * Each endpoint has to be configured prior to being used by calling
45 * snd_usb_endpoint_set_params().
46 *
47 * The model incorporates a reference counting, so that multiple users
48 * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
49 * only the first user will effectively start the URBs, and only the last
50 * one to stop it will tear the URBs down again.
51 */
52
53 /*
54 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
55 * this will overflow at approx 524 kHz
56 */
get_usb_full_speed_rate(unsigned int rate)57 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
58 {
59 return ((rate << 13) + 62) / 125;
60 }
61
62 /*
63 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
64 * this will overflow at approx 4 MHz
65 */
get_usb_high_speed_rate(unsigned int rate)66 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
67 {
68 return ((rate << 10) + 62) / 125;
69 }
70
71 /*
72 * release a urb data
73 */
release_urb_ctx(struct snd_urb_ctx * u)74 static void release_urb_ctx(struct snd_urb_ctx *u)
75 {
76 if (u->urb && u->buffer_size)
77 usb_free_coherent(u->ep->chip->dev, u->buffer_size,
78 u->urb->transfer_buffer,
79 u->urb->transfer_dma);
80 usb_free_urb(u->urb);
81 u->urb = NULL;
82 u->buffer_size = 0;
83 }
84
usb_error_string(int err)85 static const char *usb_error_string(int err)
86 {
87 switch (err) {
88 case -ENODEV:
89 return "no device";
90 case -ENOENT:
91 return "endpoint not enabled";
92 case -EPIPE:
93 return "endpoint stalled";
94 case -ENOSPC:
95 return "not enough bandwidth";
96 case -ESHUTDOWN:
97 return "device disabled";
98 case -EHOSTUNREACH:
99 return "device suspended";
100 case -EINVAL:
101 case -EAGAIN:
102 case -EFBIG:
103 case -EMSGSIZE:
104 return "internal error";
105 default:
106 return "unknown error";
107 }
108 }
109
110 /**
111 * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
112 *
113 * @ep: The snd_usb_endpoint
114 *
115 * Determine whether an endpoint is driven by an implicit feedback
116 * data endpoint source.
117 */
snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint * ep)118 int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep)
119 {
120 return ep->sync_master &&
121 ep->sync_master->type == SND_USB_ENDPOINT_TYPE_DATA &&
122 ep->type == SND_USB_ENDPOINT_TYPE_DATA &&
123 usb_pipeout(ep->pipe);
124 }
125
126 /*
127 * For streaming based on information derived from sync endpoints,
128 * prepare_outbound_urb_sizes() will call slave_next_packet_size() to
129 * determine the number of samples to be sent in the next packet.
130 *
131 * For implicit feedback, slave_next_packet_size() is unused.
132 */
snd_usb_endpoint_slave_next_packet_size(struct snd_usb_endpoint * ep)133 int snd_usb_endpoint_slave_next_packet_size(struct snd_usb_endpoint *ep)
134 {
135 unsigned long flags;
136 int ret;
137
138 if (ep->fill_max)
139 return ep->maxframesize;
140
141 spin_lock_irqsave(&ep->lock, flags);
142 ep->phase = (ep->phase & 0xffff)
143 + (ep->freqm << ep->datainterval);
144 ret = min(ep->phase >> 16, ep->maxframesize);
145 spin_unlock_irqrestore(&ep->lock, flags);
146
147 return ret;
148 }
149
150 /*
151 * For adaptive and synchronous endpoints, prepare_outbound_urb_sizes()
152 * will call next_packet_size() to determine the number of samples to be
153 * sent in the next packet.
154 */
snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint * ep)155 int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep)
156 {
157 int ret;
158
159 if (ep->fill_max)
160 return ep->maxframesize;
161
162 ep->sample_accum += ep->sample_rem;
163 if (ep->sample_accum >= ep->pps) {
164 ep->sample_accum -= ep->pps;
165 ret = ep->packsize[1];
166 } else {
167 ret = ep->packsize[0];
168 }
169
170 return ret;
171 }
172
retire_outbound_urb(struct snd_usb_endpoint * ep,struct snd_urb_ctx * urb_ctx)173 static void retire_outbound_urb(struct snd_usb_endpoint *ep,
174 struct snd_urb_ctx *urb_ctx)
175 {
176 if (ep->retire_data_urb)
177 ep->retire_data_urb(ep->data_subs, urb_ctx->urb);
178 }
179
retire_inbound_urb(struct snd_usb_endpoint * ep,struct snd_urb_ctx * urb_ctx)180 static void retire_inbound_urb(struct snd_usb_endpoint *ep,
181 struct snd_urb_ctx *urb_ctx)
182 {
183 struct urb *urb = urb_ctx->urb;
184
185 if (unlikely(ep->skip_packets > 0)) {
186 ep->skip_packets--;
187 return;
188 }
189
190 if (ep->sync_slave)
191 snd_usb_handle_sync_urb(ep->sync_slave, ep, urb);
192
193 if (ep->retire_data_urb)
194 ep->retire_data_urb(ep->data_subs, urb);
195 }
196
prepare_silent_urb(struct snd_usb_endpoint * ep,struct snd_urb_ctx * ctx)197 static void prepare_silent_urb(struct snd_usb_endpoint *ep,
198 struct snd_urb_ctx *ctx)
199 {
200 struct urb *urb = ctx->urb;
201 unsigned int offs = 0;
202 unsigned int extra = 0;
203 __le32 packet_length;
204 int i;
205
206 /* For tx_length_quirk, put packet length at start of packet */
207 if (ep->chip->tx_length_quirk)
208 extra = sizeof(packet_length);
209
210 for (i = 0; i < ctx->packets; ++i) {
211 unsigned int offset;
212 unsigned int length;
213 int counts;
214
215 if (ctx->packet_size[i])
216 counts = ctx->packet_size[i];
217 else if (ep->sync_master)
218 counts = snd_usb_endpoint_slave_next_packet_size(ep);
219 else
220 counts = snd_usb_endpoint_next_packet_size(ep);
221
222 length = counts * ep->stride; /* number of silent bytes */
223 offset = offs * ep->stride + extra * i;
224 urb->iso_frame_desc[i].offset = offset;
225 urb->iso_frame_desc[i].length = length + extra;
226 if (extra) {
227 packet_length = cpu_to_le32(length);
228 memcpy(urb->transfer_buffer + offset,
229 &packet_length, sizeof(packet_length));
230 }
231 memset(urb->transfer_buffer + offset + extra,
232 ep->silence_value, length);
233 offs += counts;
234 }
235
236 urb->number_of_packets = ctx->packets;
237 urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra;
238 }
239
240 /*
241 * Prepare a PLAYBACK urb for submission to the bus.
242 */
prepare_outbound_urb(struct snd_usb_endpoint * ep,struct snd_urb_ctx * ctx)243 static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
244 struct snd_urb_ctx *ctx)
245 {
246 struct urb *urb = ctx->urb;
247 unsigned char *cp = urb->transfer_buffer;
248
249 urb->dev = ep->chip->dev; /* we need to set this at each time */
250
251 switch (ep->type) {
252 case SND_USB_ENDPOINT_TYPE_DATA:
253 if (ep->prepare_data_urb) {
254 ep->prepare_data_urb(ep->data_subs, urb);
255 } else {
256 /* no data provider, so send silence */
257 prepare_silent_urb(ep, ctx);
258 }
259 break;
260
261 case SND_USB_ENDPOINT_TYPE_SYNC:
262 if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
263 /*
264 * fill the length and offset of each urb descriptor.
265 * the fixed 12.13 frequency is passed as 16.16 through the pipe.
266 */
267 urb->iso_frame_desc[0].length = 4;
268 urb->iso_frame_desc[0].offset = 0;
269 cp[0] = ep->freqn;
270 cp[1] = ep->freqn >> 8;
271 cp[2] = ep->freqn >> 16;
272 cp[3] = ep->freqn >> 24;
273 } else {
274 /*
275 * fill the length and offset of each urb descriptor.
276 * the fixed 10.14 frequency is passed through the pipe.
277 */
278 urb->iso_frame_desc[0].length = 3;
279 urb->iso_frame_desc[0].offset = 0;
280 cp[0] = ep->freqn >> 2;
281 cp[1] = ep->freqn >> 10;
282 cp[2] = ep->freqn >> 18;
283 }
284
285 break;
286 }
287 }
288
289 /*
290 * Prepare a CAPTURE or SYNC urb for submission to the bus.
291 */
prepare_inbound_urb(struct snd_usb_endpoint * ep,struct snd_urb_ctx * urb_ctx)292 static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
293 struct snd_urb_ctx *urb_ctx)
294 {
295 int i, offs;
296 struct urb *urb = urb_ctx->urb;
297
298 urb->dev = ep->chip->dev; /* we need to set this at each time */
299
300 switch (ep->type) {
301 case SND_USB_ENDPOINT_TYPE_DATA:
302 offs = 0;
303 for (i = 0; i < urb_ctx->packets; i++) {
304 urb->iso_frame_desc[i].offset = offs;
305 urb->iso_frame_desc[i].length = ep->curpacksize;
306 offs += ep->curpacksize;
307 }
308
309 urb->transfer_buffer_length = offs;
310 urb->number_of_packets = urb_ctx->packets;
311 break;
312
313 case SND_USB_ENDPOINT_TYPE_SYNC:
314 urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
315 urb->iso_frame_desc[0].offset = 0;
316 break;
317 }
318 }
319
320 /*
321 * Send output urbs that have been prepared previously. URBs are dequeued
322 * from ep->ready_playback_urbs and in case there aren't any available
323 * or there are no packets that have been prepared, this function does
324 * nothing.
325 *
326 * The reason why the functionality of sending and preparing URBs is separated
327 * is that host controllers don't guarantee the order in which they return
328 * inbound and outbound packets to their submitters.
329 *
330 * This function is only used for implicit feedback endpoints. For endpoints
331 * driven by dedicated sync endpoints, URBs are immediately re-submitted
332 * from their completion handler.
333 */
queue_pending_output_urbs(struct snd_usb_endpoint * ep)334 static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
335 {
336 while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {
337
338 unsigned long flags;
339 struct snd_usb_packet_info *packet;
340 struct snd_urb_ctx *ctx = NULL;
341 int err, i;
342
343 spin_lock_irqsave(&ep->lock, flags);
344 if (ep->next_packet_read_pos != ep->next_packet_write_pos) {
345 packet = ep->next_packet + ep->next_packet_read_pos;
346 ep->next_packet_read_pos++;
347 ep->next_packet_read_pos %= MAX_URBS;
348
349 /* take URB out of FIFO */
350 if (!list_empty(&ep->ready_playback_urbs)) {
351 ctx = list_first_entry(&ep->ready_playback_urbs,
352 struct snd_urb_ctx, ready_list);
353 list_del_init(&ctx->ready_list);
354 }
355 }
356 spin_unlock_irqrestore(&ep->lock, flags);
357
358 if (ctx == NULL)
359 return;
360
361 /* copy over the length information */
362 for (i = 0; i < packet->packets; i++)
363 ctx->packet_size[i] = packet->packet_size[i];
364
365 /* call the data handler to fill in playback data */
366 prepare_outbound_urb(ep, ctx);
367
368 err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
369 if (err < 0)
370 usb_audio_err(ep->chip,
371 "Unable to submit urb #%d: %d (urb %p)\n",
372 ctx->index, err, ctx->urb);
373 else
374 set_bit(ctx->index, &ep->active_mask);
375 }
376 }
377
378 /*
379 * complete callback for urbs
380 */
snd_complete_urb(struct urb * urb)381 static void snd_complete_urb(struct urb *urb)
382 {
383 struct snd_urb_ctx *ctx = urb->context;
384 struct snd_usb_endpoint *ep = ctx->ep;
385 struct snd_pcm_substream *substream;
386 unsigned long flags;
387 int err;
388
389 if (unlikely(urb->status == -ENOENT || /* unlinked */
390 urb->status == -ENODEV || /* device removed */
391 urb->status == -ECONNRESET || /* unlinked */
392 urb->status == -ESHUTDOWN)) /* device disabled */
393 goto exit_clear;
394 /* device disconnected */
395 if (unlikely(atomic_read(&ep->chip->shutdown)))
396 goto exit_clear;
397
398 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
399 goto exit_clear;
400
401 if (usb_pipeout(ep->pipe)) {
402 retire_outbound_urb(ep, ctx);
403 /* can be stopped during retire callback */
404 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
405 goto exit_clear;
406
407 if (snd_usb_endpoint_implicit_feedback_sink(ep)) {
408 spin_lock_irqsave(&ep->lock, flags);
409 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
410 spin_unlock_irqrestore(&ep->lock, flags);
411 queue_pending_output_urbs(ep);
412
413 goto exit_clear;
414 }
415
416 prepare_outbound_urb(ep, ctx);
417 /* can be stopped during prepare callback */
418 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
419 goto exit_clear;
420 } else {
421 retire_inbound_urb(ep, ctx);
422 /* can be stopped during retire callback */
423 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
424 goto exit_clear;
425
426 prepare_inbound_urb(ep, ctx);
427 }
428
429 err = usb_submit_urb(urb, GFP_ATOMIC);
430 if (err == 0)
431 return;
432
433 usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
434 if (ep->data_subs && ep->data_subs->pcm_substream) {
435 substream = ep->data_subs->pcm_substream;
436 snd_pcm_stop_xrun(substream);
437 }
438
439 exit_clear:
440 clear_bit(ctx->index, &ep->active_mask);
441 }
442
443 /**
444 * snd_usb_add_endpoint: Add an endpoint to an USB audio chip
445 *
446 * @chip: The chip
447 * @alts: The USB host interface
448 * @ep_num: The number of the endpoint to use
449 * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE
450 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
451 *
452 * If the requested endpoint has not been added to the given chip before,
453 * a new instance is created. Otherwise, a pointer to the previoulsy
454 * created instance is returned. In case of any error, NULL is returned.
455 *
456 * New endpoints will be added to chip->ep_list and must be freed by
457 * calling snd_usb_endpoint_free().
458 *
459 * For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that
460 * bNumEndpoints > 1 beforehand.
461 */
snd_usb_add_endpoint(struct snd_usb_audio * chip,struct usb_host_interface * alts,int ep_num,int direction,int type)462 struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
463 struct usb_host_interface *alts,
464 int ep_num, int direction, int type)
465 {
466 struct snd_usb_endpoint *ep;
467 int is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK;
468
469 if (WARN_ON(!alts))
470 return NULL;
471
472 mutex_lock(&chip->mutex);
473
474 list_for_each_entry(ep, &chip->ep_list, list) {
475 if (ep->ep_num == ep_num &&
476 ep->iface == alts->desc.bInterfaceNumber &&
477 ep->altsetting == alts->desc.bAlternateSetting) {
478 usb_audio_dbg(ep->chip,
479 "Re-using EP %x in iface %d,%d @%p\n",
480 ep_num, ep->iface, ep->altsetting, ep);
481 goto __exit_unlock;
482 }
483 }
484
485 usb_audio_dbg(chip, "Creating new %s %s endpoint #%x\n",
486 is_playback ? "playback" : "capture",
487 type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
488 ep_num);
489
490 ep = kzalloc(sizeof(*ep), GFP_KERNEL);
491 if (!ep)
492 goto __exit_unlock;
493
494 ep->chip = chip;
495 spin_lock_init(&ep->lock);
496 ep->type = type;
497 ep->ep_num = ep_num;
498 ep->iface = alts->desc.bInterfaceNumber;
499 ep->altsetting = alts->desc.bAlternateSetting;
500 INIT_LIST_HEAD(&ep->ready_playback_urbs);
501 ep_num &= USB_ENDPOINT_NUMBER_MASK;
502
503 if (is_playback)
504 ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
505 else
506 ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
507
508 if (type == SND_USB_ENDPOINT_TYPE_SYNC) {
509 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
510 get_endpoint(alts, 1)->bRefresh >= 1 &&
511 get_endpoint(alts, 1)->bRefresh <= 9)
512 ep->syncinterval = get_endpoint(alts, 1)->bRefresh;
513 else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
514 ep->syncinterval = 1;
515 else if (get_endpoint(alts, 1)->bInterval >= 1 &&
516 get_endpoint(alts, 1)->bInterval <= 16)
517 ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
518 else
519 ep->syncinterval = 3;
520
521 ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
522 }
523
524 list_add_tail(&ep->list, &chip->ep_list);
525
526 ep->is_implicit_feedback = 0;
527
528 __exit_unlock:
529 mutex_unlock(&chip->mutex);
530
531 return ep;
532 }
533
534 /*
535 * wait until all urbs are processed.
536 */
wait_clear_urbs(struct snd_usb_endpoint * ep)537 static int wait_clear_urbs(struct snd_usb_endpoint *ep)
538 {
539 unsigned long end_time = jiffies + msecs_to_jiffies(1000);
540 int alive;
541
542 do {
543 alive = bitmap_weight(&ep->active_mask, ep->nurbs);
544 if (!alive)
545 break;
546
547 schedule_timeout_uninterruptible(1);
548 } while (time_before(jiffies, end_time));
549
550 if (alive)
551 usb_audio_err(ep->chip,
552 "timeout: still %d active urbs on EP #%x\n",
553 alive, ep->ep_num);
554 clear_bit(EP_FLAG_STOPPING, &ep->flags);
555
556 ep->data_subs = NULL;
557 ep->sync_slave = NULL;
558 ep->retire_data_urb = NULL;
559 ep->prepare_data_urb = NULL;
560
561 return 0;
562 }
563
564 /* sync the pending stop operation;
565 * this function itself doesn't trigger the stop operation
566 */
snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint * ep)567 void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep)
568 {
569 if (ep && test_bit(EP_FLAG_STOPPING, &ep->flags))
570 wait_clear_urbs(ep);
571 }
572
573 /*
574 * unlink active urbs.
575 */
deactivate_urbs(struct snd_usb_endpoint * ep,bool force)576 static int deactivate_urbs(struct snd_usb_endpoint *ep, bool force)
577 {
578 unsigned int i;
579
580 clear_bit(EP_FLAG_RUNNING, &ep->flags);
581
582 INIT_LIST_HEAD(&ep->ready_playback_urbs);
583 ep->next_packet_read_pos = 0;
584 ep->next_packet_write_pos = 0;
585
586 for (i = 0; i < ep->nurbs; i++) {
587 if (test_bit(i, &ep->active_mask)) {
588 if (!test_and_set_bit(i, &ep->unlink_mask)) {
589 struct urb *u = ep->urb[i].urb;
590 usb_unlink_urb(u);
591 }
592 }
593 }
594
595 return 0;
596 }
597
598 /*
599 * release an endpoint's urbs
600 */
release_urbs(struct snd_usb_endpoint * ep,int force)601 static void release_urbs(struct snd_usb_endpoint *ep, int force)
602 {
603 int i;
604
605 /* route incoming urbs to nirvana */
606 ep->retire_data_urb = NULL;
607 ep->prepare_data_urb = NULL;
608
609 /* stop urbs */
610 deactivate_urbs(ep, force);
611 wait_clear_urbs(ep);
612
613 for (i = 0; i < ep->nurbs; i++)
614 release_urb_ctx(&ep->urb[i]);
615
616 usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
617 ep->syncbuf, ep->sync_dma);
618
619 ep->syncbuf = NULL;
620 ep->nurbs = 0;
621 }
622
623 /*
624 * Check data endpoint for format differences
625 */
check_ep_params(struct snd_usb_endpoint * ep,snd_pcm_format_t pcm_format,unsigned int channels,unsigned int period_bytes,unsigned int frames_per_period,unsigned int periods_per_buffer,struct audioformat * fmt,struct snd_usb_endpoint * sync_ep)626 static bool check_ep_params(struct snd_usb_endpoint *ep,
627 snd_pcm_format_t pcm_format,
628 unsigned int channels,
629 unsigned int period_bytes,
630 unsigned int frames_per_period,
631 unsigned int periods_per_buffer,
632 struct audioformat *fmt,
633 struct snd_usb_endpoint *sync_ep)
634 {
635 unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
636 unsigned int max_packs_per_period, urbs_per_period, urb_packs;
637 unsigned int max_urbs;
638 int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels;
639 int tx_length_quirk = (ep->chip->tx_length_quirk &&
640 usb_pipeout(ep->pipe));
641 bool ret = 1;
642
643 if (pcm_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
644 /*
645 * When operating in DSD DOP mode, the size of a sample frame
646 * in hardware differs from the actual physical format width
647 * because we need to make room for the DOP markers.
648 */
649 frame_bits += channels << 3;
650 }
651
652 ret = ret && (ep->datainterval == fmt->datainterval);
653 ret = ret && (ep->stride == frame_bits >> 3);
654
655 switch (pcm_format) {
656 case SNDRV_PCM_FORMAT_U8:
657 ret = ret && (ep->silence_value == 0x80);
658 break;
659 case SNDRV_PCM_FORMAT_DSD_U8:
660 case SNDRV_PCM_FORMAT_DSD_U16_LE:
661 case SNDRV_PCM_FORMAT_DSD_U32_LE:
662 case SNDRV_PCM_FORMAT_DSD_U16_BE:
663 case SNDRV_PCM_FORMAT_DSD_U32_BE:
664 ret = ret && (ep->silence_value == 0x69);
665 break;
666 default:
667 ret = ret && (ep->silence_value == 0);
668 }
669
670 /* assume max. frequency is 50% higher than nominal */
671 ret = ret && (ep->freqmax == ep->freqn + (ep->freqn >> 1));
672 /* Round up freqmax to nearest integer in order to calculate maximum
673 * packet size, which must represent a whole number of frames.
674 * This is accomplished by adding 0x0.ffff before converting the
675 * Q16.16 format into integer.
676 * In order to accurately calculate the maximum packet size when
677 * the data interval is more than 1 (i.e. ep->datainterval > 0),
678 * multiply by the data interval prior to rounding. For instance,
679 * a freqmax of 41 kHz will result in a max packet size of 6 (5.125)
680 * frames with a data interval of 1, but 11 (10.25) frames with a
681 * data interval of 2.
682 * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
683 * maximum datainterval value of 3, at USB full speed, higher for
684 * USB high speed, noting that ep->freqmax is in units of
685 * frames per packet in Q16.16 format.)
686 */
687 maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
688 (frame_bits >> 3);
689 if (tx_length_quirk)
690 maxsize += sizeof(__le32); /* Space for length descriptor */
691 /* but wMaxPacketSize might reduce this */
692 if (ep->maxpacksize && ep->maxpacksize < maxsize) {
693 /* whatever fits into a max. size packet */
694 unsigned int data_maxsize = maxsize = ep->maxpacksize;
695
696 if (tx_length_quirk)
697 /* Need to remove the length descriptor to calc freq */
698 data_maxsize -= sizeof(__le32);
699 ret = ret && (ep->freqmax == (data_maxsize / (frame_bits >> 3))
700 << (16 - ep->datainterval));
701 }
702
703 if (ep->fill_max)
704 ret = ret && (ep->curpacksize == ep->maxpacksize);
705 else
706 ret = ret && (ep->curpacksize == maxsize);
707
708 if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL) {
709 packs_per_ms = 8 >> ep->datainterval;
710 max_packs_per_urb = MAX_PACKS_HS;
711 } else {
712 packs_per_ms = 1;
713 max_packs_per_urb = MAX_PACKS;
714 }
715 if (sync_ep && !snd_usb_endpoint_implicit_feedback_sink(ep))
716 max_packs_per_urb = min(max_packs_per_urb,
717 1U << sync_ep->syncinterval);
718 max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
719
720 /*
721 * Capture endpoints need to use small URBs because there's no way
722 * to tell in advance where the next period will end, and we don't
723 * want the next URB to complete much after the period ends.
724 *
725 * Playback endpoints with implicit sync much use the same parameters
726 * as their corresponding capture endpoint.
727 */
728 if (usb_pipein(ep->pipe) ||
729 snd_usb_endpoint_implicit_feedback_sink(ep)) {
730
731 urb_packs = packs_per_ms;
732 /*
733 * Wireless devices can poll at a max rate of once per 4ms.
734 * For dataintervals less than 5, increase the packet count to
735 * allow the host controller to use bursting to fill in the
736 * gaps.
737 */
738 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_WIRELESS) {
739 int interval = ep->datainterval;
740
741 while (interval < 5) {
742 urb_packs <<= 1;
743 ++interval;
744 }
745 }
746 /* make capture URBs <= 1 ms and smaller than a period */
747 urb_packs = min(max_packs_per_urb, urb_packs);
748 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
749 urb_packs >>= 1;
750 ret = ret && (ep->nurbs == MAX_URBS);
751
752 /*
753 * Playback endpoints without implicit sync are adjusted so that
754 * a period fits as evenly as possible in the smallest number of
755 * URBs. The total number of URBs is adjusted to the size of the
756 * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits.
757 */
758 } else {
759 /* determine how small a packet can be */
760 minsize = (ep->freqn >> (16 - ep->datainterval)) *
761 (frame_bits >> 3);
762 /* with sync from device, assume it can be 12% lower */
763 if (sync_ep)
764 minsize -= minsize >> 3;
765 minsize = max(minsize, 1u);
766
767 /* how many packets will contain an entire ALSA period? */
768 max_packs_per_period = DIV_ROUND_UP(period_bytes, minsize);
769
770 /* how many URBs will contain a period? */
771 urbs_per_period = DIV_ROUND_UP(max_packs_per_period,
772 max_packs_per_urb);
773 /* how many packets are needed in each URB? */
774 urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);
775
776 /* limit the number of frames in a single URB */
777 ret = ret && (ep->max_urb_frames ==
778 DIV_ROUND_UP(frames_per_period, urbs_per_period));
779
780 /* try to use enough URBs to contain an entire ALSA buffer */
781 max_urbs = min((unsigned) MAX_URBS,
782 MAX_QUEUE * packs_per_ms / urb_packs);
783 ret = ret && (ep->nurbs == min(max_urbs,
784 urbs_per_period * periods_per_buffer));
785 }
786
787 ret = ret && (ep->datainterval == fmt->datainterval);
788 ret = ret && (ep->maxpacksize == fmt->maxpacksize);
789 ret = ret &&
790 (ep->fill_max == !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX));
791
792 return ret;
793 }
794
795 /*
796 * configure a data endpoint
797 */
data_ep_set_params(struct snd_usb_endpoint * ep,snd_pcm_format_t pcm_format,unsigned int channels,unsigned int period_bytes,unsigned int frames_per_period,unsigned int periods_per_buffer,struct audioformat * fmt,struct snd_usb_endpoint * sync_ep)798 static int data_ep_set_params(struct snd_usb_endpoint *ep,
799 snd_pcm_format_t pcm_format,
800 unsigned int channels,
801 unsigned int period_bytes,
802 unsigned int frames_per_period,
803 unsigned int periods_per_buffer,
804 struct audioformat *fmt,
805 struct snd_usb_endpoint *sync_ep)
806 {
807 unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
808 unsigned int max_packs_per_period, urbs_per_period, urb_packs;
809 unsigned int max_urbs, i;
810 int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels;
811 int tx_length_quirk = (ep->chip->tx_length_quirk &&
812 usb_pipeout(ep->pipe));
813
814 if (pcm_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
815 /*
816 * When operating in DSD DOP mode, the size of a sample frame
817 * in hardware differs from the actual physical format width
818 * because we need to make room for the DOP markers.
819 */
820 frame_bits += channels << 3;
821 }
822
823 ep->datainterval = fmt->datainterval;
824 ep->stride = frame_bits >> 3;
825
826 switch (pcm_format) {
827 case SNDRV_PCM_FORMAT_U8:
828 ep->silence_value = 0x80;
829 break;
830 case SNDRV_PCM_FORMAT_DSD_U8:
831 case SNDRV_PCM_FORMAT_DSD_U16_LE:
832 case SNDRV_PCM_FORMAT_DSD_U32_LE:
833 case SNDRV_PCM_FORMAT_DSD_U16_BE:
834 case SNDRV_PCM_FORMAT_DSD_U32_BE:
835 ep->silence_value = 0x69;
836 break;
837 default:
838 ep->silence_value = 0;
839 }
840
841 /* assume max. frequency is 50% higher than nominal */
842 ep->freqmax = ep->freqn + (ep->freqn >> 1);
843 /* Round up freqmax to nearest integer in order to calculate maximum
844 * packet size, which must represent a whole number of frames.
845 * This is accomplished by adding 0x0.ffff before converting the
846 * Q16.16 format into integer.
847 * In order to accurately calculate the maximum packet size when
848 * the data interval is more than 1 (i.e. ep->datainterval > 0),
849 * multiply by the data interval prior to rounding. For instance,
850 * a freqmax of 41 kHz will result in a max packet size of 6 (5.125)
851 * frames with a data interval of 1, but 11 (10.25) frames with a
852 * data interval of 2.
853 * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
854 * maximum datainterval value of 3, at USB full speed, higher for
855 * USB high speed, noting that ep->freqmax is in units of
856 * frames per packet in Q16.16 format.)
857 */
858 maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
859 (frame_bits >> 3);
860 if (tx_length_quirk)
861 maxsize += sizeof(__le32); /* Space for length descriptor */
862 /* but wMaxPacketSize might reduce this */
863 if (ep->maxpacksize && ep->maxpacksize < maxsize) {
864 /* whatever fits into a max. size packet */
865 unsigned int data_maxsize = maxsize = ep->maxpacksize;
866
867 if (tx_length_quirk)
868 /* Need to remove the length descriptor to calc freq */
869 data_maxsize -= sizeof(__le32);
870 ep->freqmax = (data_maxsize / (frame_bits >> 3))
871 << (16 - ep->datainterval);
872 }
873
874 if (ep->fill_max)
875 ep->curpacksize = ep->maxpacksize;
876 else
877 ep->curpacksize = maxsize;
878
879 if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL) {
880 packs_per_ms = 8 >> ep->datainterval;
881 max_packs_per_urb = MAX_PACKS_HS;
882 } else {
883 packs_per_ms = 1;
884 max_packs_per_urb = MAX_PACKS;
885 }
886 if (sync_ep && !snd_usb_endpoint_implicit_feedback_sink(ep))
887 max_packs_per_urb = min(max_packs_per_urb,
888 1U << sync_ep->syncinterval);
889 max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
890
891 /*
892 * Capture endpoints need to use small URBs because there's no way
893 * to tell in advance where the next period will end, and we don't
894 * want the next URB to complete much after the period ends.
895 *
896 * Playback endpoints with implicit sync much use the same parameters
897 * as their corresponding capture endpoint.
898 */
899 if (usb_pipein(ep->pipe) ||
900 snd_usb_endpoint_implicit_feedback_sink(ep)) {
901
902 urb_packs = packs_per_ms;
903 /*
904 * Wireless devices can poll at a max rate of once per 4ms.
905 * For dataintervals less than 5, increase the packet count to
906 * allow the host controller to use bursting to fill in the
907 * gaps.
908 */
909 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_WIRELESS) {
910 int interval = ep->datainterval;
911 while (interval < 5) {
912 urb_packs <<= 1;
913 ++interval;
914 }
915 }
916 /* make capture URBs <= 1 ms and smaller than a period */
917 urb_packs = min(max_packs_per_urb, urb_packs);
918 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
919 urb_packs >>= 1;
920 ep->nurbs = MAX_URBS;
921
922 /*
923 * Playback endpoints without implicit sync are adjusted so that
924 * a period fits as evenly as possible in the smallest number of
925 * URBs. The total number of URBs is adjusted to the size of the
926 * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits.
927 */
928 } else {
929 /* determine how small a packet can be */
930 minsize = (ep->freqn >> (16 - ep->datainterval)) *
931 (frame_bits >> 3);
932 /* with sync from device, assume it can be 12% lower */
933 if (sync_ep)
934 minsize -= minsize >> 3;
935 minsize = max(minsize, 1u);
936
937 /* how many packets will contain an entire ALSA period? */
938 max_packs_per_period = DIV_ROUND_UP(period_bytes, minsize);
939
940 /* how many URBs will contain a period? */
941 urbs_per_period = DIV_ROUND_UP(max_packs_per_period,
942 max_packs_per_urb);
943 /* how many packets are needed in each URB? */
944 urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);
945
946 /* limit the number of frames in a single URB */
947 ep->max_urb_frames = DIV_ROUND_UP(frames_per_period,
948 urbs_per_period);
949
950 /* try to use enough URBs to contain an entire ALSA buffer */
951 max_urbs = min((unsigned) MAX_URBS,
952 MAX_QUEUE * packs_per_ms / urb_packs);
953 ep->nurbs = min(max_urbs, urbs_per_period * periods_per_buffer);
954 }
955
956 /* allocate and initialize data urbs */
957 for (i = 0; i < ep->nurbs; i++) {
958 struct snd_urb_ctx *u = &ep->urb[i];
959 u->index = i;
960 u->ep = ep;
961 u->packets = urb_packs;
962 u->buffer_size = maxsize * u->packets;
963
964 if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
965 u->packets++; /* for transfer delimiter */
966 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
967 if (!u->urb)
968 goto out_of_memory;
969
970 u->urb->transfer_buffer =
971 usb_alloc_coherent(ep->chip->dev, u->buffer_size,
972 GFP_KERNEL, &u->urb->transfer_dma);
973 if (!u->urb->transfer_buffer)
974 goto out_of_memory;
975 u->urb->pipe = ep->pipe;
976 u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
977 u->urb->interval = 1 << ep->datainterval;
978 u->urb->context = u;
979 u->urb->complete = snd_complete_urb;
980 INIT_LIST_HEAD(&u->ready_list);
981 }
982
983 return 0;
984
985 out_of_memory:
986 release_urbs(ep, 0);
987 return -ENOMEM;
988 }
989
990 /*
991 * configure a sync endpoint
992 */
sync_ep_set_params(struct snd_usb_endpoint * ep)993 static int sync_ep_set_params(struct snd_usb_endpoint *ep)
994 {
995 int i;
996
997 ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
998 GFP_KERNEL, &ep->sync_dma);
999 if (!ep->syncbuf)
1000 return -ENOMEM;
1001
1002 ep->nurbs = SYNC_URBS;
1003 for (i = 0; i < SYNC_URBS; i++) {
1004 struct snd_urb_ctx *u = &ep->urb[i];
1005 u->index = i;
1006 u->ep = ep;
1007 u->packets = 1;
1008 u->urb = usb_alloc_urb(1, GFP_KERNEL);
1009 if (!u->urb)
1010 goto out_of_memory;
1011 u->urb->transfer_buffer = ep->syncbuf + i * 4;
1012 u->urb->transfer_dma = ep->sync_dma + i * 4;
1013 u->urb->transfer_buffer_length = 4;
1014 u->urb->pipe = ep->pipe;
1015 u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
1016 u->urb->number_of_packets = 1;
1017 u->urb->interval = 1 << ep->syncinterval;
1018 u->urb->context = u;
1019 u->urb->complete = snd_complete_urb;
1020 }
1021
1022 return 0;
1023
1024 out_of_memory:
1025 release_urbs(ep, 0);
1026 return -ENOMEM;
1027 }
1028
1029 /**
1030 * snd_usb_endpoint_set_params: configure an snd_usb_endpoint
1031 *
1032 * @ep: the snd_usb_endpoint to configure
1033 * @pcm_format: the audio fomat.
1034 * @channels: the number of audio channels.
1035 * @period_bytes: the number of bytes in one alsa period.
1036 * @period_frames: the number of frames in one alsa period.
1037 * @buffer_periods: the number of periods in one alsa buffer.
1038 * @rate: the frame rate.
1039 * @fmt: the USB audio format information
1040 * @sync_ep: the sync endpoint to use, if any
1041 *
1042 * Determine the number of URBs to be used on this endpoint.
1043 * An endpoint must be configured before it can be started.
1044 * An endpoint that is already running can not be reconfigured.
1045 */
snd_usb_endpoint_set_params(struct snd_usb_endpoint * ep,snd_pcm_format_t pcm_format,unsigned int channels,unsigned int period_bytes,unsigned int period_frames,unsigned int buffer_periods,unsigned int rate,struct audioformat * fmt,struct snd_usb_endpoint * sync_ep)1046 int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
1047 snd_pcm_format_t pcm_format,
1048 unsigned int channels,
1049 unsigned int period_bytes,
1050 unsigned int period_frames,
1051 unsigned int buffer_periods,
1052 unsigned int rate,
1053 struct audioformat *fmt,
1054 struct snd_usb_endpoint *sync_ep)
1055 {
1056 int err;
1057
1058 if (ep->use_count != 0) {
1059 bool check = ep->is_implicit_feedback &&
1060 check_ep_params(ep, pcm_format,
1061 channels, period_bytes,
1062 period_frames, buffer_periods,
1063 fmt, sync_ep);
1064
1065 if (!check) {
1066 usb_audio_warn(ep->chip,
1067 "Unable to change format on ep #%x: already in use\n",
1068 ep->ep_num);
1069 return -EBUSY;
1070 }
1071
1072 usb_audio_dbg(ep->chip,
1073 "Ep #%x already in use as implicit feedback but format not changed\n",
1074 ep->ep_num);
1075 return 0;
1076 }
1077
1078 /* release old buffers, if any */
1079 release_urbs(ep, 0);
1080
1081 ep->datainterval = fmt->datainterval;
1082 ep->maxpacksize = fmt->maxpacksize;
1083 ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
1084
1085 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL) {
1086 ep->freqn = get_usb_full_speed_rate(rate);
1087 ep->pps = 1000 >> ep->datainterval;
1088 } else {
1089 ep->freqn = get_usb_high_speed_rate(rate);
1090 ep->pps = 8000 >> ep->datainterval;
1091 }
1092
1093 ep->sample_rem = rate % ep->pps;
1094 ep->packsize[0] = rate / ep->pps;
1095 ep->packsize[1] = (rate + (ep->pps - 1)) / ep->pps;
1096
1097 /* calculate the frequency in 16.16 format */
1098 ep->freqm = ep->freqn;
1099 ep->freqshift = INT_MIN;
1100
1101 ep->phase = 0;
1102
1103 switch (ep->type) {
1104 case SND_USB_ENDPOINT_TYPE_DATA:
1105 err = data_ep_set_params(ep, pcm_format, channels,
1106 period_bytes, period_frames,
1107 buffer_periods, fmt, sync_ep);
1108 break;
1109 case SND_USB_ENDPOINT_TYPE_SYNC:
1110 err = sync_ep_set_params(ep);
1111 break;
1112 default:
1113 err = -EINVAL;
1114 }
1115
1116 usb_audio_dbg(ep->chip,
1117 "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
1118 ep->ep_num, ep->type, ep->nurbs, err);
1119
1120 return err;
1121 }
1122
1123 /**
1124 * snd_usb_endpoint_start: start an snd_usb_endpoint
1125 *
1126 * @ep: the endpoint to start
1127 *
1128 * A call to this function will increment the use count of the endpoint.
1129 * In case it is not already running, the URBs for this endpoint will be
1130 * submitted. Otherwise, this function does nothing.
1131 *
1132 * Must be balanced to calls of snd_usb_endpoint_stop().
1133 *
1134 * Returns an error if the URB submission failed, 0 in all other cases.
1135 */
snd_usb_endpoint_start(struct snd_usb_endpoint * ep)1136 int snd_usb_endpoint_start(struct snd_usb_endpoint *ep)
1137 {
1138 int err;
1139 unsigned int i;
1140
1141 if (atomic_read(&ep->chip->shutdown))
1142 return -EBADFD;
1143
1144 /* already running? */
1145 if (++ep->use_count != 1)
1146 return 0;
1147
1148 /* just to be sure */
1149 deactivate_urbs(ep, false);
1150
1151 ep->active_mask = 0;
1152 ep->unlink_mask = 0;
1153 ep->phase = 0;
1154 ep->sample_accum = 0;
1155
1156 snd_usb_endpoint_start_quirk(ep);
1157
1158 /*
1159 * If this endpoint has a data endpoint as implicit feedback source,
1160 * don't start the urbs here. Instead, mark them all as available,
1161 * wait for the record urbs to return and queue the playback urbs
1162 * from that context.
1163 */
1164
1165 set_bit(EP_FLAG_RUNNING, &ep->flags);
1166
1167 if (snd_usb_endpoint_implicit_feedback_sink(ep)) {
1168 for (i = 0; i < ep->nurbs; i++) {
1169 struct snd_urb_ctx *ctx = ep->urb + i;
1170 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
1171 }
1172
1173 return 0;
1174 }
1175
1176 for (i = 0; i < ep->nurbs; i++) {
1177 struct urb *urb = ep->urb[i].urb;
1178
1179 if (snd_BUG_ON(!urb))
1180 goto __error;
1181
1182 if (usb_pipeout(ep->pipe)) {
1183 prepare_outbound_urb(ep, urb->context);
1184 } else {
1185 prepare_inbound_urb(ep, urb->context);
1186 }
1187
1188 err = usb_submit_urb(urb, GFP_ATOMIC);
1189 if (err < 0) {
1190 usb_audio_err(ep->chip,
1191 "cannot submit urb %d, error %d: %s\n",
1192 i, err, usb_error_string(err));
1193 goto __error;
1194 }
1195 set_bit(i, &ep->active_mask);
1196 }
1197
1198 return 0;
1199
1200 __error:
1201 clear_bit(EP_FLAG_RUNNING, &ep->flags);
1202 ep->use_count--;
1203 deactivate_urbs(ep, false);
1204 return -EPIPE;
1205 }
1206
1207 /**
1208 * snd_usb_endpoint_stop: stop an snd_usb_endpoint
1209 *
1210 * @ep: the endpoint to stop (may be NULL)
1211 *
1212 * A call to this function will decrement the use count of the endpoint.
1213 * In case the last user has requested the endpoint stop, the URBs will
1214 * actually be deactivated.
1215 *
1216 * Must be balanced to calls of snd_usb_endpoint_start().
1217 *
1218 * The caller needs to synchronize the pending stop operation via
1219 * snd_usb_endpoint_sync_pending_stop().
1220 */
snd_usb_endpoint_stop(struct snd_usb_endpoint * ep)1221 void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep)
1222 {
1223 if (!ep)
1224 return;
1225
1226 if (snd_BUG_ON(ep->use_count == 0))
1227 return;
1228
1229 if (--ep->use_count == 0) {
1230 deactivate_urbs(ep, false);
1231 set_bit(EP_FLAG_STOPPING, &ep->flags);
1232 }
1233 }
1234
1235 /**
1236 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint
1237 *
1238 * @ep: the endpoint to deactivate
1239 *
1240 * If the endpoint is not currently in use, this functions will
1241 * deactivate its associated URBs.
1242 *
1243 * In case of any active users, this functions does nothing.
1244 */
snd_usb_endpoint_deactivate(struct snd_usb_endpoint * ep)1245 void snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
1246 {
1247 if (!ep)
1248 return;
1249
1250 if (ep->use_count != 0)
1251 return;
1252
1253 deactivate_urbs(ep, true);
1254 wait_clear_urbs(ep);
1255 }
1256
1257 /**
1258 * snd_usb_endpoint_release: Tear down an snd_usb_endpoint
1259 *
1260 * @ep: the endpoint to release
1261 *
1262 * This function does not care for the endpoint's use count but will tear
1263 * down all the streaming URBs immediately.
1264 */
snd_usb_endpoint_release(struct snd_usb_endpoint * ep)1265 void snd_usb_endpoint_release(struct snd_usb_endpoint *ep)
1266 {
1267 release_urbs(ep, 1);
1268 }
1269
1270 /**
1271 * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
1272 *
1273 * @ep: the endpoint to free
1274 *
1275 * This free all resources of the given ep.
1276 */
snd_usb_endpoint_free(struct snd_usb_endpoint * ep)1277 void snd_usb_endpoint_free(struct snd_usb_endpoint *ep)
1278 {
1279 kfree(ep);
1280 }
1281
1282 /**
1283 * snd_usb_handle_sync_urb: parse an USB sync packet
1284 *
1285 * @ep: the endpoint to handle the packet
1286 * @sender: the sending endpoint
1287 * @urb: the received packet
1288 *
1289 * This function is called from the context of an endpoint that received
1290 * the packet and is used to let another endpoint object handle the payload.
1291 */
snd_usb_handle_sync_urb(struct snd_usb_endpoint * ep,struct snd_usb_endpoint * sender,const struct urb * urb)1292 void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
1293 struct snd_usb_endpoint *sender,
1294 const struct urb *urb)
1295 {
1296 int shift;
1297 unsigned int f;
1298 unsigned long flags;
1299
1300 snd_BUG_ON(ep == sender);
1301
1302 /*
1303 * In case the endpoint is operating in implicit feedback mode, prepare
1304 * a new outbound URB that has the same layout as the received packet
1305 * and add it to the list of pending urbs. queue_pending_output_urbs()
1306 * will take care of them later.
1307 */
1308 if (snd_usb_endpoint_implicit_feedback_sink(ep) &&
1309 ep->use_count != 0) {
1310
1311 /* implicit feedback case */
1312 int i, bytes = 0;
1313 struct snd_urb_ctx *in_ctx;
1314 struct snd_usb_packet_info *out_packet;
1315
1316 in_ctx = urb->context;
1317
1318 /* Count overall packet size */
1319 for (i = 0; i < in_ctx->packets; i++)
1320 if (urb->iso_frame_desc[i].status == 0)
1321 bytes += urb->iso_frame_desc[i].actual_length;
1322
1323 /*
1324 * skip empty packets. At least M-Audio's Fast Track Ultra stops
1325 * streaming once it received a 0-byte OUT URB
1326 */
1327 if (bytes == 0)
1328 return;
1329
1330 spin_lock_irqsave(&ep->lock, flags);
1331 out_packet = ep->next_packet + ep->next_packet_write_pos;
1332
1333 /*
1334 * Iterate through the inbound packet and prepare the lengths
1335 * for the output packet. The OUT packet we are about to send
1336 * will have the same amount of payload bytes per stride as the
1337 * IN packet we just received. Since the actual size is scaled
1338 * by the stride, use the sender stride to calculate the length
1339 * in case the number of channels differ between the implicitly
1340 * fed-back endpoint and the synchronizing endpoint.
1341 */
1342
1343 out_packet->packets = in_ctx->packets;
1344 for (i = 0; i < in_ctx->packets; i++) {
1345 if (urb->iso_frame_desc[i].status == 0)
1346 out_packet->packet_size[i] =
1347 urb->iso_frame_desc[i].actual_length / sender->stride;
1348 else
1349 out_packet->packet_size[i] = 0;
1350 }
1351
1352 ep->next_packet_write_pos++;
1353 ep->next_packet_write_pos %= MAX_URBS;
1354 spin_unlock_irqrestore(&ep->lock, flags);
1355 queue_pending_output_urbs(ep);
1356
1357 return;
1358 }
1359
1360 /*
1361 * process after playback sync complete
1362 *
1363 * Full speed devices report feedback values in 10.14 format as samples
1364 * per frame, high speed devices in 16.16 format as samples per
1365 * microframe.
1366 *
1367 * Because the Audio Class 1 spec was written before USB 2.0, many high
1368 * speed devices use a wrong interpretation, some others use an
1369 * entirely different format.
1370 *
1371 * Therefore, we cannot predict what format any particular device uses
1372 * and must detect it automatically.
1373 */
1374
1375 if (urb->iso_frame_desc[0].status != 0 ||
1376 urb->iso_frame_desc[0].actual_length < 3)
1377 return;
1378
1379 f = le32_to_cpup(urb->transfer_buffer);
1380 if (urb->iso_frame_desc[0].actual_length == 3)
1381 f &= 0x00ffffff;
1382 else
1383 f &= 0x0fffffff;
1384
1385 if (f == 0)
1386 return;
1387
1388 if (unlikely(sender->tenor_fb_quirk)) {
1389 /*
1390 * Devices based on Tenor 8802 chipsets (TEAC UD-H01
1391 * and others) sometimes change the feedback value
1392 * by +/- 0x1.0000.
1393 */
1394 if (f < ep->freqn - 0x8000)
1395 f += 0xf000;
1396 else if (f > ep->freqn + 0x8000)
1397 f -= 0xf000;
1398 } else if (unlikely(ep->freqshift == INT_MIN)) {
1399 /*
1400 * The first time we see a feedback value, determine its format
1401 * by shifting it left or right until it matches the nominal
1402 * frequency value. This assumes that the feedback does not
1403 * differ from the nominal value more than +50% or -25%.
1404 */
1405 shift = 0;
1406 while (f < ep->freqn - ep->freqn / 4) {
1407 f <<= 1;
1408 shift++;
1409 }
1410 while (f > ep->freqn + ep->freqn / 2) {
1411 f >>= 1;
1412 shift--;
1413 }
1414 ep->freqshift = shift;
1415 } else if (ep->freqshift >= 0)
1416 f <<= ep->freqshift;
1417 else
1418 f >>= -ep->freqshift;
1419
1420 if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1421 /*
1422 * If the frequency looks valid, set it.
1423 * This value is referred to in prepare_playback_urb().
1424 */
1425 spin_lock_irqsave(&ep->lock, flags);
1426 ep->freqm = f;
1427 spin_unlock_irqrestore(&ep->lock, flags);
1428 } else {
1429 /*
1430 * Out of range; maybe the shift value is wrong.
1431 * Reset it so that we autodetect again the next time.
1432 */
1433 ep->freqshift = INT_MIN;
1434 }
1435 }
1436
1437