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 */ 57static 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 */ 66static 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 */ 74static 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 85static 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 */ 118int 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 */ 133int 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 */ 155int 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 173static 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 180static 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 197static 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 */ 243static 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 */ 292static 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 */ 334static 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 */ 381static 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 439exit_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 */ 462struct 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 */ 537static 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 */ 567void 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 */ 576static 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 */ 601static 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 */ 626static 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 */ 798static 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 985out_of_memory: 986 release_urbs(ep, 0); 987 return -ENOMEM; 988} 989 990/* 991 * configure a sync endpoint 992 */ 993static 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 1024out_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 */ 1046int 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 */ 1136int 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 */ 1221void 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 */ 1245void 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 */ 1265void 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 */ 1277void 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 */ 1292void 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