Lines Matching +full:phase +full:- +full:locked
1 // SPDX-License-Identifier: GPL-2.0-or-later
42 atomic_t locked;
99 if (u->urb && u->buffer_size)
100 usb_free_coherent(u->ep->chip->dev, u->buffer_size,
101 u->urb->transfer_buffer,
102 u->urb->transfer_dma);
103 usb_free_urb(u->urb);
104 u->urb = NULL;
105 u->buffer_size = 0;
111 case -ENODEV:
113 case -ENOENT:
115 case -EPIPE:
117 case -ENOSPC:
119 case -ESHUTDOWN:
121 case -EHOSTUNREACH:
123 case -EINVAL:
124 case -EAGAIN:
125 case -EFBIG:
126 case -EMSGSIZE:
135 return atomic_read(&ep->state) == EP_STATE_RUNNING;
140 return atomic_try_cmpxchg(&ep->state, &old, new);
153 return ep->implicit_fb_sync && usb_pipeout(ep->pipe);
166 unsigned int phase;
169 if (ep->fill_max)
170 return ep->maxframesize;
172 guard(spinlock_irqsave)(&ep->lock);
173 phase = (ep->phase & 0xffff) + (ep->freqm << ep->datainterval);
174 ret = min(phase >> 16, ep->maxframesize);
176 ret = -EAGAIN;
178 ep->phase = phase;
191 if (ep->fill_max)
192 return ep->maxframesize;
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];
199 ret = ep->packsize[0];
202 ret = -EAGAIN;
204 ep->sample_accum = sample_accum;
213 * If the size is equal or exceeds @avail, don't proceed but return -EAGAIN
222 packet = ctx->packet_size[idx];
225 return -EAGAIN;
229 if (ep->sync_source)
240 data_subs = READ_ONCE(ep->data_subs);
241 if (data_subs && ep->retire_data_urb)
242 ep->retire_data_urb(data_subs, urb);
248 call_retire_callback(ep, urb_ctx->urb);
258 struct urb *urb = urb_ctx->urb;
261 if (unlikely(ep->skip_packets > 0)) {
262 ep->skip_packets--;
266 sync_sink = READ_ONCE(ep->sync_sink);
275 return chip->quirk_flags & QUIRK_FLAG_TX_LENGTH;
281 struct urb *urb = ctx->urb;
288 if (has_tx_length_quirk(ep->chip))
291 for (i = 0; i < ctx->packets; ++i) {
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;
303 memcpy(urb->transfer_buffer + offset,
306 memset(urb->transfer_buffer + offset + extra,
307 ep->silence_value, length);
311 urb->number_of_packets = ctx->packets;
312 urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra;
313 ctx->queued = 0;
323 struct urb *urb = ctx->urb;
324 unsigned char *cp = urb->transfer_buffer;
327 urb->dev = ep->chip->dev; /* we need to set this at each time */
329 switch (ep->type) {
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);
339 if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
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;
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;
374 struct urb *urb = urb_ctx->urb;
376 urb->dev = ep->chip->dev; /* we need to set this at each time */
378 switch (ep->type) {
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;
387 urb->transfer_buffer_length = offs;
388 urb->number_of_packets = urb_ctx->packets;
392 urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
393 urb->iso_frame_desc[0].offset = 0;
405 data_subs = READ_ONCE(ep->data_subs);
408 psubs = data_subs->pcm_substream;
409 if (psubs && psubs->runtime &&
410 psubs->runtime->state == SNDRV_PCM_STATE_RUNNING)
419 p = ep->next_packet + (ep->next_packet_head + ep->next_packet_queued) %
420 ARRAY_SIZE(ep->next_packet);
421 ep->next_packet_queued++;
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--;
440 guard(spinlock_irqsave)(&ep->lock);
441 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
446 * from ep->ready_playback_urbs and in case there aren't any available
454 * This function is used both for implicit feedback endpoints and in low-
467 scoped_guard(spinlock_irqsave, &ep->lock) {
468 if ((!implicit_fb || ep->next_packet_queued > 0) &&
469 !list_empty(&ep->ready_playback_urbs)) {
471 ctx = list_first_entry(&ep->ready_playback_urbs,
473 list_del_init(&ctx->ready_list);
484 for (i = 0; i < packet->packets; i++)
485 ctx->packet_size[i] = packet->packet_size[i];
494 /* push back to ready list again for -EAGAIN */
495 if (err == -EAGAIN) {
502 return -EPIPE;
505 if (!atomic_read(&ep->chip->shutdown))
506 err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
508 err = -ENODEV;
510 if (!atomic_read(&ep->chip->shutdown)) {
511 usb_audio_err(ep->chip,
513 ctx->index, err, __func__);
517 return -EPIPE;
520 set_bit(ctx->index, &ep->active_mask);
521 atomic_inc(&ep->submitted_urbs);
532 struct snd_urb_ctx *ctx = urb->context;
533 struct snd_usb_endpoint *ep = ctx->ep;
536 if (unlikely(urb->status == -ENOENT || /* unlinked */
537 urb->status == -ENODEV || /* device removed */
538 urb->status == -ECONNRESET || /* unlinked */
539 urb->status == -ESHUTDOWN)) /* device disabled */
542 if (unlikely(atomic_read(&ep->chip->shutdown)))
548 if (usb_pipeout(ep->pipe)) {
554 /* in low-latency and implicit-feedback modes, push back the
557 if (ep->lowlatency_playback ||
560 clear_bit(ctx->index, &ep->active_mask);
563 if (atomic_dec_and_test(&ep->submitted_urbs) &&
569 /* in non-lowlatency mode, no error handling for prepare */
583 if (!atomic_read(&ep->chip->shutdown))
586 err = -ENODEV;
590 if (!atomic_read(&ep->chip->shutdown)) {
591 usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
596 clear_bit(ctx->index, &ep->active_mask);
597 atomic_dec(&ep->submitted_urbs);
610 list_for_each_entry(ip, &chip->iface_ref_list, list)
611 if (ip->iface == iface)
617 ip->iface = iface;
618 list_add_tail(&ip->list, &chip->iface_ref_list);
628 list_for_each_entry(ref, &chip->clock_ref_list, list)
629 if (ref->clock == clock)
635 ref->clock = clock;
636 atomic_set(&ref->locked, 0);
637 list_add_tail(&ref->list, &chip->clock_ref_list);
650 list_for_each_entry(ep, &chip->ep_list, list) {
651 if (ep->ep_num == ep_num)
673 * New endpoints will be added to chip->ep_list and freed by
693 return -ENOMEM;
695 ep->chip = chip;
696 spin_lock_init(&ep->lock);
697 ep->type = type;
698 ep->ep_num = ep_num;
699 INIT_LIST_HEAD(&ep->ready_playback_urbs);
700 atomic_set(&ep->submitted_urbs, 0);
705 ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
707 ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
709 list_add_tail(&ep->list, &chip->ep_list);
720 alts = snd_usb_get_host_interface(chip, ep->iface, ep->altsetting);
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;
733 ep->syncinterval = 3;
735 ep->syncmaxsize = le16_to_cpu(desc->wMaxPacketSize);
742 if (!ep->opened)
744 if (ep->cur_audiofmt != fp)
746 if (ep->cur_rate != params_rate(params) ||
747 ep->cur_format != params_format(params) ||
748 ep->cur_period_frames != params_period_size(params) ||
749 ep->cur_buffer_periods != params_periods(params))
763 guard(mutex)(&chip->mutex);
771 * It's reference-counted, and only the first opener is allowed to set up
788 int ep_num = is_sync_ep ? fp->sync_ep : fp->endpoint;
790 guard(mutex)(&chip->mutex);
797 if (!ep->opened) {
799 ep->iface = fp->sync_iface;
800 ep->altsetting = fp->sync_altsetting;
801 ep->ep_idx = fp->sync_ep_idx;
803 ep->iface = fp->iface;
804 ep->altsetting = fp->altsetting;
805 ep->ep_idx = fp->ep_idx;
808 ep_num, ep->iface, ep->altsetting, ep->ep_idx);
810 ep->iface_ref = iface_ref_find(chip, ep->iface);
811 if (!ep->iface_ref)
814 if (fp->protocol != UAC_VERSION_1) {
815 ep->clock_ref = clock_ref_find(chip, fp->clock);
816 if (!ep->clock_ref)
818 ep->clock_ref->opened++;
821 ep->cur_audiofmt = fp;
822 ep->cur_channels = fp->channels;
823 ep->cur_rate = params_rate(params);
824 ep->cur_format = params_format(params);
825 ep->cur_frame_bytes = snd_pcm_format_physical_width(ep->cur_format) *
826 ep->cur_channels / 8;
827 ep->cur_period_frames = params_period_size(params);
828 ep->cur_period_bytes = ep->cur_period_frames * ep->cur_frame_bytes;
829 ep->cur_buffer_periods = params_periods(params);
831 if (ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
834 ep->implicit_fb_sync = fp->implicit_fb;
835 ep->need_setup = true;
836 ep->need_prepare = true;
837 ep->fixed_rate = fixed_rate;
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);
846 if (WARN_ON(!ep->iface_ref))
856 ep_num, ep->opened);
859 if (!ep->iface_ref->opened++)
860 ep->iface_ref->need_setup = true;
862 ep->opened++;
875 data_ep->sync_source = sync_ep;
892 ep->prepare_data_urb = prepare;
893 ep->retire_data_urb = retire;
895 ep->lowlatency_playback = data_subs->lowlatency_playback;
897 ep->lowlatency_playback = false;
898 WRITE_ONCE(ep->data_subs, data_subs);
905 int altset = set ? ep->altsetting : 0;
910 if (ep->iface_ref->altset == altset)
913 if (unlikely(atomic_read(&chip->shutdown)))
914 return -ENODEV;
917 ep->iface, altset, ep->ep_num);
919 err = usb_set_interface(chip->dev, ep->iface, altset);
921 if (err == -EPROTO && ++retries <= max_retries) {
922 msleep(5 * (1 << (retries - 1)));
927 ep->iface, altset, err);
931 if (chip->quirk_flags & QUIRK_FLAG_IFACE_DELAY)
933 ep->iface_ref->altset = altset;
945 guard(mutex)(&chip->mutex);
947 ep->ep_num, ep->opened);
949 if (!--ep->iface_ref->opened &&
950 !(chip->quirk_flags & QUIRK_FLAG_IFACE_SKIP_CLOSE))
953 if (!--ep->opened) {
954 if (ep->clock_ref) {
955 if (!--ep->clock_ref->opened)
956 ep->clock_ref->rate = 0;
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);
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;
986 if (atomic_read(&ep->state) != EP_STATE_STOPPING)
990 alive = atomic_read(&ep->submitted_urbs);
998 usb_audio_err(ep->chip,
1000 alive, ep->ep_num);
1003 ep->sync_sink = NULL;
1028 if (!force && atomic_read(&ep->running))
1029 return -EBUSY;
1034 scoped_guard(spinlock_irqsave, &ep->lock) {
1035 INIT_LIST_HEAD(&ep->ready_playback_urbs);
1036 ep->next_packet_head = 0;
1037 ep->next_packet_queued = 0;
1043 for (i = 0; i < ep->nurbs; i++) {
1044 if (test_bit(i, &ep->active_mask)) {
1045 if (!test_and_set_bit(i, &ep->unlink_mask)) {
1046 struct urb *u = ep->urb[i].urb;
1072 for (i = 0; i < ep->nurbs; i++)
1073 release_urb_ctx(&ep->urb[i]);
1075 usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
1076 ep->syncbuf, ep->sync_dma);
1078 ep->syncbuf = NULL;
1079 ep->nurbs = 0;
1088 struct snd_usb_audio *chip = ep->chip;
1092 const struct audioformat *fmt = ep->cur_audiofmt;
1093 int frame_bits = ep->cur_frame_bytes * 8;
1095 usb_pipeout(ep->pipe));
1098 ep->ep_num, ep->pipe);
1100 if (ep->cur_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
1106 frame_bits += ep->cur_channels << 3;
1109 ep->datainterval = fmt->datainterval;
1110 ep->stride = frame_bits >> 3;
1112 switch (ep->cur_format) {
1114 ep->silence_value = 0x80;
1121 ep->silence_value = 0x69;
1124 ep->silence_value = 0;
1128 ep->freqmax = ep->freqn + (ep->freqn >> 1);
1134 * the data interval is more than 1 (i.e. ep->datainterval > 0),
1139 * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
1141 * USB high speed, noting that ep->freqmax is in units of
1144 maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
1149 if (ep->maxpacksize && ep->maxpacksize < maxsize) {
1151 unsigned int data_maxsize = maxsize = ep->maxpacksize;
1155 data_maxsize -= sizeof(__le32);
1156 ep->freqmax = (data_maxsize / (frame_bits >> 3))
1157 << (16 - ep->datainterval);
1160 if (ep->fill_max)
1161 ep->curpacksize = ep->maxpacksize;
1163 ep->curpacksize = maxsize;
1165 if (snd_usb_get_speed(chip->dev) != USB_SPEED_FULL) {
1166 packs_per_ms = 8 >> ep->datainterval;
1172 if (ep->sync_source && !ep->implicit_fb_sync)
1174 1U << ep->sync_source->syncinterval);
1175 max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
1185 if (usb_pipein(ep->pipe) || ep->implicit_fb_sync) {
1189 while (urb_packs > 1 && urb_packs * maxsize >= ep->cur_period_bytes)
1191 ep->nurbs = MAX_URBS;
1201 minsize = (ep->freqn >> (16 - ep->datainterval)) *
1204 if (ep->sync_source)
1205 minsize -= minsize >> 3;
1209 max_packs_per_period = DIV_ROUND_UP(ep->cur_period_bytes, minsize);
1218 ep->max_urb_frames = DIV_ROUND_UP(ep->cur_period_frames,
1224 ep->nurbs = min(max_urbs, urbs_per_period * ep->cur_buffer_periods);
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;
1235 if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
1236 u->packets++; /* for transfer delimiter */
1237 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
1238 if (!u->urb)
1241 u->urb->transfer_buffer =
1242 usb_alloc_coherent(chip->dev, u->buffer_size,
1243 GFP_KERNEL, &u->urb->transfer_dma);
1244 if (!u->urb->transfer_buffer)
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(&u->ready_list);
1258 return -ENOMEM;
1266 struct snd_usb_audio *chip = ep->chip;
1270 ep->ep_num, ep->pipe);
1272 ep->syncbuf = usb_alloc_coherent(chip->dev, SYNC_URBS * 4,
1273 GFP_KERNEL, &ep->sync_dma);
1274 if (!ep->syncbuf)
1275 return -ENOMEM;
1277 ep->nurbs = SYNC_URBS;
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(1, GFP_KERNEL);
1284 if (!u->urb)
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;
1301 return -ENOMEM;
1308 struct snd_usb_clock_ref *clock = ep->clock_ref;
1309 int rate = ep->cur_rate;
1311 if (!clock || clock->rate == rate)
1313 if (clock->rate) {
1314 if (atomic_read(&clock->locked))
1315 return clock->rate;
1316 if (clock->rate != rate) {
1318 clock->rate, rate, ep->ep_num);
1319 return clock->rate;
1322 clock->rate = rate;
1323 clock->need_setup = true;
1338 const struct audioformat *fmt = ep->cur_audiofmt;
1341 guard(mutex)(&chip->mutex);
1342 if (!ep->need_setup)
1350 ep->datainterval = fmt->datainterval;
1351 ep->maxpacksize = fmt->maxpacksize;
1352 ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
1354 if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) {
1355 ep->freqn = get_usb_full_speed_rate(ep->cur_rate);
1356 ep->pps = 1000 >> ep->datainterval;
1358 ep->freqn = get_usb_high_speed_rate(ep->cur_rate);
1359 ep->pps = 8000 >> ep->datainterval;
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;
1367 ep->freqm = ep->freqn;
1368 ep->freqshift = INT_MIN;
1370 ep->phase = 0;
1372 switch (ep->type) {
1380 err = -EINVAL;
1383 usb_audio_dbg(chip, "Set up %d URBS, ret=%d\n", ep->nurbs, err);
1389 ep->maxframesize = ep->maxpacksize / ep->cur_frame_bytes;
1390 ep->curframesize = ep->curpacksize / ep->cur_frame_bytes;
1394 ep->need_setup = false;
1404 struct snd_usb_clock_ref *clock = ep->clock_ref;
1410 if (clock && !clock->need_setup)
1413 if (!ep->fixed_rate) {
1414 err = snd_usb_init_sample_rate(chip, ep->cur_audiofmt, rate);
1417 clock->rate = 0; /* reset rate */
1423 clock->need_setup = false;
1444 guard(mutex)(&chip->mutex);
1445 if (WARN_ON(!ep->iface_ref))
1447 if (!ep->need_prepare)
1451 if (!ep->iface_ref->need_setup) {
1455 if (ep->cur_audiofmt->protocol == UAC_VERSION_1) {
1469 iface_first = ep->cur_audiofmt->protocol == UAC_VERSION_1;
1471 if (chip->quirk_flags & QUIRK_FLAG_SET_IFACE_FIRST)
1479 err = snd_usb_init_pitch(chip, ep->cur_audiofmt);
1487 err = snd_usb_select_mode_quirk(chip, ep->cur_audiofmt);
1498 ep->iface_ref->need_setup = false;
1501 ep->need_prepare = false;
1514 guard(mutex)(&chip->mutex);
1515 list_for_each_entry(ref, &chip->clock_ref_list, list) {
1516 if (ref->clock == clock) {
1517 rate = ref->rate;
1539 bool is_playback = usb_pipeout(ep->pipe);
1543 if (atomic_read(&ep->chip->shutdown))
1544 return -EBADFD;
1546 if (ep->sync_source)
1547 WRITE_ONCE(ep->sync_source->sync_sink, ep);
1549 usb_audio_dbg(ep->chip, "Starting %s EP 0x%x (running %d)\n",
1550 ep_type_name(ep->type), ep->ep_num,
1551 atomic_read(&ep->running));
1554 if (atomic_inc_return(&ep->running) != 1)
1557 if (ep->clock_ref)
1558 atomic_inc(&ep->clock_ref->locked);
1560 ep->active_mask = 0;
1561 ep->unlink_mask = 0;
1562 ep->phase = 0;
1563 ep->sample_accum = 0;
1578 !(ep->chip->quirk_flags & QUIRK_FLAG_PLAYBACK_FIRST)) {
1579 usb_audio_dbg(ep->chip, "No URB submission due to implicit fb sync\n");
1584 for (i = 0; i < ep->nurbs; i++) {
1585 struct urb *urb = ep->urb[i].urb;
1591 err = prepare_outbound_urb(ep, urb->context, true);
1593 err = prepare_inbound_urb(ep, urb->context);
1596 if (err == -EAGAIN)
1598 usb_audio_dbg(ep->chip,
1600 ep->ep_num, err);
1604 if (!atomic_read(&ep->chip->shutdown))
1607 err = -ENODEV;
1609 if (!atomic_read(&ep->chip->shutdown))
1610 usb_audio_err(ep->chip,
1615 set_bit(i, &ep->active_mask);
1616 atomic_inc(&ep->submitted_urbs);
1620 usb_audio_dbg(ep->chip, "XRUN at starting EP 0x%x\n",
1621 ep->ep_num);
1625 usb_audio_dbg(ep->chip, "%d URBs submitted for EP 0x%x\n",
1626 i, ep->ep_num);
1631 for (; i < ep->nurbs; i++)
1632 push_back_to_ready_list(ep, ep->urb + i);
1639 return -EPIPE;
1646 * @keep_pending: keep in-flight URBs
1662 usb_audio_dbg(ep->chip, "Stopping %s EP 0x%x (running %d)\n",
1663 ep_type_name(ep->type), ep->ep_num,
1664 atomic_read(&ep->running));
1666 if (snd_BUG_ON(!atomic_read(&ep->running)))
1669 if (!atomic_dec_return(&ep->running)) {
1670 if (ep->sync_source)
1671 WRITE_ONCE(ep->sync_source->sync_sink, NULL);
1673 if (ep->clock_ref)
1674 atomic_dec(&ep->clock_ref->locked);
1676 if (ep->chip->quirk_flags & QUIRK_FLAG_FORCE_IFACE_RESET &&
1677 usb_pipeout(ep->pipe)) {
1678 ep->need_prepare = true;
1679 if (ep->iface_ref)
1680 ep->iface_ref->need_setup = true;
1710 list_for_each_entry_safe(ep, en, &chip->ep_list, list)
1713 list_for_each_entry_safe(ip, in, &chip->iface_ref_list, list)
1716 list_for_each_entry_safe(cp, cn, &chip->clock_ref_list, list)
1747 atomic_read(&ep->running)) {
1754 in_ctx = urb->context;
1757 for (i = 0; i < in_ctx->packets; i++)
1758 if (urb->iso_frame_desc[i].status == 0)
1759 bytes += urb->iso_frame_desc[i].actual_length;
1762 * skip empty packets. At least M-Audio's Fast Track Ultra stops
1763 * streaming once it received a 0-byte OUT URB
1768 spin_lock_irqsave(&ep->lock, flags);
1769 if (ep->next_packet_queued >= ARRAY_SIZE(ep->next_packet)) {
1770 spin_unlock_irqrestore(&ep->lock, flags);
1771 usb_audio_err(ep->chip,
1773 ep->ep_num);
1787 * fed-back endpoint and the synchronizing endpoint.
1790 out_packet->packets = in_ctx->packets;
1791 for (i = 0; i < in_ctx->packets; i++) {
1792 if (urb->iso_frame_desc[i].status == 0)
1793 out_packet->packet_size[i] =
1794 urb->iso_frame_desc[i].actual_length / sender->stride;
1796 out_packet->packet_size[i] = 0;
1799 spin_unlock_irqrestore(&ep->lock, flags);
1820 if (urb->iso_frame_desc[0].status != 0 ||
1821 urb->iso_frame_desc[0].actual_length < 3)
1824 f = le32_to_cpup(urb->transfer_buffer);
1825 if (urb->iso_frame_desc[0].actual_length == 3)
1833 if (unlikely(sender->tenor_fb_quirk)) {
1835 * Devices based on Tenor 8802 chipsets (TEAC UD-H01
1837 * by +/- 0x1.0000.
1839 if (f < ep->freqn - 0x8000)
1841 else if (f > ep->freqn + 0x8000)
1842 f -= 0xf000;
1843 } else if (unlikely(ep->freqshift == INT_MIN)) {
1848 * differ from the nominal value more than +50% or -25%.
1851 while (f < ep->freqn - ep->freqn / 4) {
1855 while (f > ep->freqn + ep->freqn / 2) {
1857 shift--;
1859 ep->freqshift = shift;
1860 } else if (ep->freqshift >= 0)
1861 f <<= ep->freqshift;
1863 f >>= -ep->freqshift;
1865 if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1870 guard(spinlock_irqsave)(&ep->lock);
1871 ep->freqm = f;
1877 ep->freqshift = INT_MIN;