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