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 } else { 392 retire_inbound_urb(ep, ctx); 393 /* can be stopped during retire callback */ 394 if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags))) 395 goto exit_clear; 396 397 prepare_inbound_urb(ep, ctx); 398 } 399 400 err = usb_submit_urb(urb, GFP_ATOMIC); 401 if (err == 0) 402 return; 403 404 usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err); 405 if (ep->data_subs && ep->data_subs->pcm_substream) { 406 substream = ep->data_subs->pcm_substream; 407 snd_pcm_stop_xrun(substream); 408 } 409 410 exit_clear: 411 clear_bit(ctx->index, &ep->active_mask); 412 } 413 414 /** 415 * snd_usb_add_endpoint: Add an endpoint to an USB audio chip 416 * 417 * @chip: The chip 418 * @alts: The USB host interface 419 * @ep_num: The number of the endpoint to use 420 * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE 421 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC 422 * 423 * If the requested endpoint has not been added to the given chip before, 424 * a new instance is created. Otherwise, a pointer to the previoulsy 425 * created instance is returned. In case of any error, NULL is returned. 426 * 427 * New endpoints will be added to chip->ep_list and must be freed by 428 * calling snd_usb_endpoint_free(). 429 * 430 * For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that 431 * bNumEndpoints > 1 beforehand. 432 */ 433 struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip, 434 struct usb_host_interface *alts, 435 int ep_num, int direction, int type) 436 { 437 struct snd_usb_endpoint *ep; 438 int is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK; 439 440 if (WARN_ON(!alts)) 441 return NULL; 442 443 mutex_lock(&chip->mutex); 444 445 list_for_each_entry(ep, &chip->ep_list, list) { 446 if (ep->ep_num == ep_num && 447 ep->iface == alts->desc.bInterfaceNumber && 448 ep->altsetting == alts->desc.bAlternateSetting) { 449 usb_audio_dbg(ep->chip, 450 "Re-using EP %x in iface %d,%d @%p\n", 451 ep_num, ep->iface, ep->altsetting, ep); 452 goto __exit_unlock; 453 } 454 } 455 456 usb_audio_dbg(chip, "Creating new %s %s endpoint #%x\n", 457 is_playback ? "playback" : "capture", 458 type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync", 459 ep_num); 460 461 ep = kzalloc(sizeof(*ep), GFP_KERNEL); 462 if (!ep) 463 goto __exit_unlock; 464 465 ep->chip = chip; 466 spin_lock_init(&ep->lock); 467 ep->type = type; 468 ep->ep_num = ep_num; 469 ep->iface = alts->desc.bInterfaceNumber; 470 ep->altsetting = alts->desc.bAlternateSetting; 471 INIT_LIST_HEAD(&ep->ready_playback_urbs); 472 ep_num &= USB_ENDPOINT_NUMBER_MASK; 473 474 if (is_playback) 475 ep->pipe = usb_sndisocpipe(chip->dev, ep_num); 476 else 477 ep->pipe = usb_rcvisocpipe(chip->dev, ep_num); 478 479 if (type == SND_USB_ENDPOINT_TYPE_SYNC) { 480 if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && 481 get_endpoint(alts, 1)->bRefresh >= 1 && 482 get_endpoint(alts, 1)->bRefresh <= 9) 483 ep->syncinterval = get_endpoint(alts, 1)->bRefresh; 484 else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL) 485 ep->syncinterval = 1; 486 else if (get_endpoint(alts, 1)->bInterval >= 1 && 487 get_endpoint(alts, 1)->bInterval <= 16) 488 ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1; 489 else 490 ep->syncinterval = 3; 491 492 ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize); 493 } 494 495 list_add_tail(&ep->list, &chip->ep_list); 496 497 __exit_unlock: 498 mutex_unlock(&chip->mutex); 499 500 return ep; 501 } 502 503 /* 504 * wait until all urbs are processed. 505 */ 506 static int wait_clear_urbs(struct snd_usb_endpoint *ep) 507 { 508 unsigned long end_time = jiffies + msecs_to_jiffies(1000); 509 int alive; 510 511 do { 512 alive = bitmap_weight(&ep->active_mask, ep->nurbs); 513 if (!alive) 514 break; 515 516 schedule_timeout_uninterruptible(1); 517 } while (time_before(jiffies, end_time)); 518 519 if (alive) 520 usb_audio_err(ep->chip, 521 "timeout: still %d active urbs on EP #%x\n", 522 alive, ep->ep_num); 523 clear_bit(EP_FLAG_STOPPING, &ep->flags); 524 525 ep->data_subs = NULL; 526 ep->sync_slave = NULL; 527 ep->retire_data_urb = NULL; 528 ep->prepare_data_urb = NULL; 529 530 return 0; 531 } 532 533 /* sync the pending stop operation; 534 * this function itself doesn't trigger the stop operation 535 */ 536 void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep) 537 { 538 if (ep && test_bit(EP_FLAG_STOPPING, &ep->flags)) 539 wait_clear_urbs(ep); 540 } 541 542 /* 543 * unlink active urbs. 544 */ 545 static int deactivate_urbs(struct snd_usb_endpoint *ep, bool force) 546 { 547 unsigned int i; 548 549 if (!force && atomic_read(&ep->chip->shutdown)) /* to be sure... */ 550 return -EBADFD; 551 552 clear_bit(EP_FLAG_RUNNING, &ep->flags); 553 554 INIT_LIST_HEAD(&ep->ready_playback_urbs); 555 ep->next_packet_read_pos = 0; 556 ep->next_packet_write_pos = 0; 557 558 for (i = 0; i < ep->nurbs; i++) { 559 if (test_bit(i, &ep->active_mask)) { 560 if (!test_and_set_bit(i, &ep->unlink_mask)) { 561 struct urb *u = ep->urb[i].urb; 562 usb_unlink_urb(u); 563 } 564 } 565 } 566 567 return 0; 568 } 569 570 /* 571 * release an endpoint's urbs 572 */ 573 static void release_urbs(struct snd_usb_endpoint *ep, int force) 574 { 575 int i; 576 577 /* route incoming urbs to nirvana */ 578 ep->retire_data_urb = NULL; 579 ep->prepare_data_urb = NULL; 580 581 /* stop urbs */ 582 deactivate_urbs(ep, force); 583 wait_clear_urbs(ep); 584 585 for (i = 0; i < ep->nurbs; i++) 586 release_urb_ctx(&ep->urb[i]); 587 588 if (ep->syncbuf) 589 usb_free_coherent(ep->chip->dev, SYNC_URBS * 4, 590 ep->syncbuf, ep->sync_dma); 591 592 ep->syncbuf = NULL; 593 ep->nurbs = 0; 594 } 595 596 /* 597 * configure a data endpoint 598 */ 599 static int data_ep_set_params(struct snd_usb_endpoint *ep, 600 snd_pcm_format_t pcm_format, 601 unsigned int channels, 602 unsigned int period_bytes, 603 unsigned int frames_per_period, 604 unsigned int periods_per_buffer, 605 struct audioformat *fmt, 606 struct snd_usb_endpoint *sync_ep) 607 { 608 unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb; 609 unsigned int max_packs_per_period, urbs_per_period, urb_packs; 610 unsigned int max_urbs, i; 611 int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels; 612 int tx_length_quirk = (ep->chip->tx_length_quirk && 613 usb_pipeout(ep->pipe)); 614 615 if (pcm_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) { 616 /* 617 * When operating in DSD DOP mode, the size of a sample frame 618 * in hardware differs from the actual physical format width 619 * because we need to make room for the DOP markers. 620 */ 621 frame_bits += channels << 3; 622 } 623 624 ep->datainterval = fmt->datainterval; 625 ep->stride = frame_bits >> 3; 626 627 switch (pcm_format) { 628 case SNDRV_PCM_FORMAT_U8: 629 ep->silence_value = 0x80; 630 break; 631 case SNDRV_PCM_FORMAT_DSD_U8: 632 case SNDRV_PCM_FORMAT_DSD_U16_LE: 633 case SNDRV_PCM_FORMAT_DSD_U32_LE: 634 case SNDRV_PCM_FORMAT_DSD_U16_BE: 635 case SNDRV_PCM_FORMAT_DSD_U32_BE: 636 ep->silence_value = 0x69; 637 break; 638 default: 639 ep->silence_value = 0; 640 } 641 642 /* assume max. frequency is 50% higher than nominal */ 643 ep->freqmax = ep->freqn + (ep->freqn >> 1); 644 /* Round up freqmax to nearest integer in order to calculate maximum 645 * packet size, which must represent a whole number of frames. 646 * This is accomplished by adding 0x0.ffff before converting the 647 * Q16.16 format into integer. 648 * In order to accurately calculate the maximum packet size when 649 * the data interval is more than 1 (i.e. ep->datainterval > 0), 650 * multiply by the data interval prior to rounding. For instance, 651 * a freqmax of 41 kHz will result in a max packet size of 6 (5.125) 652 * frames with a data interval of 1, but 11 (10.25) frames with a 653 * data interval of 2. 654 * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the 655 * maximum datainterval value of 3, at USB full speed, higher for 656 * USB high speed, noting that ep->freqmax is in units of 657 * frames per packet in Q16.16 format.) 658 */ 659 maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) * 660 (frame_bits >> 3); 661 if (tx_length_quirk) 662 maxsize += sizeof(__le32); /* Space for length descriptor */ 663 /* but wMaxPacketSize might reduce this */ 664 if (ep->maxpacksize && ep->maxpacksize < maxsize) { 665 /* whatever fits into a max. size packet */ 666 unsigned int data_maxsize = maxsize = ep->maxpacksize; 667 668 if (tx_length_quirk) 669 /* Need to remove the length descriptor to calc freq */ 670 data_maxsize -= sizeof(__le32); 671 ep->freqmax = (data_maxsize / (frame_bits >> 3)) 672 << (16 - ep->datainterval); 673 } 674 675 if (ep->fill_max) 676 ep->curpacksize = ep->maxpacksize; 677 else 678 ep->curpacksize = maxsize; 679 680 if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL) { 681 packs_per_ms = 8 >> ep->datainterval; 682 max_packs_per_urb = MAX_PACKS_HS; 683 } else { 684 packs_per_ms = 1; 685 max_packs_per_urb = MAX_PACKS; 686 } 687 if (sync_ep && !snd_usb_endpoint_implicit_feedback_sink(ep)) 688 max_packs_per_urb = min(max_packs_per_urb, 689 1U << sync_ep->syncinterval); 690 max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval); 691 692 /* 693 * Capture endpoints need to use small URBs because there's no way 694 * to tell in advance where the next period will end, and we don't 695 * want the next URB to complete much after the period ends. 696 * 697 * Playback endpoints with implicit sync much use the same parameters 698 * as their corresponding capture endpoint. 699 */ 700 if (usb_pipein(ep->pipe) || 701 snd_usb_endpoint_implicit_feedback_sink(ep)) { 702 703 urb_packs = packs_per_ms; 704 /* 705 * Wireless devices can poll at a max rate of once per 4ms. 706 * For dataintervals less than 5, increase the packet count to 707 * allow the host controller to use bursting to fill in the 708 * gaps. 709 */ 710 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_WIRELESS) { 711 int interval = ep->datainterval; 712 while (interval < 5) { 713 urb_packs <<= 1; 714 ++interval; 715 } 716 } 717 /* make capture URBs <= 1 ms and smaller than a period */ 718 urb_packs = min(max_packs_per_urb, urb_packs); 719 while (urb_packs > 1 && urb_packs * maxsize >= period_bytes) 720 urb_packs >>= 1; 721 ep->nurbs = MAX_URBS; 722 723 /* 724 * Playback endpoints without implicit sync are adjusted so that 725 * a period fits as evenly as possible in the smallest number of 726 * URBs. The total number of URBs is adjusted to the size of the 727 * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits. 728 */ 729 } else { 730 /* determine how small a packet can be */ 731 minsize = (ep->freqn >> (16 - ep->datainterval)) * 732 (frame_bits >> 3); 733 /* with sync from device, assume it can be 12% lower */ 734 if (sync_ep) 735 minsize -= minsize >> 3; 736 minsize = max(minsize, 1u); 737 738 /* how many packets will contain an entire ALSA period? */ 739 max_packs_per_period = DIV_ROUND_UP(period_bytes, minsize); 740 741 /* how many URBs will contain a period? */ 742 urbs_per_period = DIV_ROUND_UP(max_packs_per_period, 743 max_packs_per_urb); 744 /* how many packets are needed in each URB? */ 745 urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period); 746 747 /* limit the number of frames in a single URB */ 748 ep->max_urb_frames = DIV_ROUND_UP(frames_per_period, 749 urbs_per_period); 750 751 /* try to use enough URBs to contain an entire ALSA buffer */ 752 max_urbs = min((unsigned) MAX_URBS, 753 MAX_QUEUE * packs_per_ms / urb_packs); 754 ep->nurbs = min(max_urbs, urbs_per_period * periods_per_buffer); 755 } 756 757 /* allocate and initialize data urbs */ 758 for (i = 0; i < ep->nurbs; i++) { 759 struct snd_urb_ctx *u = &ep->urb[i]; 760 u->index = i; 761 u->ep = ep; 762 u->packets = urb_packs; 763 u->buffer_size = maxsize * u->packets; 764 765 if (fmt->fmt_type == UAC_FORMAT_TYPE_II) 766 u->packets++; /* for transfer delimiter */ 767 u->urb = usb_alloc_urb(u->packets, GFP_KERNEL); 768 if (!u->urb) 769 goto out_of_memory; 770 771 u->urb->transfer_buffer = 772 usb_alloc_coherent(ep->chip->dev, u->buffer_size, 773 GFP_KERNEL, &u->urb->transfer_dma); 774 if (!u->urb->transfer_buffer) 775 goto out_of_memory; 776 u->urb->pipe = ep->pipe; 777 u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 778 u->urb->interval = 1 << ep->datainterval; 779 u->urb->context = u; 780 u->urb->complete = snd_complete_urb; 781 INIT_LIST_HEAD(&u->ready_list); 782 } 783 784 return 0; 785 786 out_of_memory: 787 release_urbs(ep, 0); 788 return -ENOMEM; 789 } 790 791 /* 792 * configure a sync endpoint 793 */ 794 static int sync_ep_set_params(struct snd_usb_endpoint *ep) 795 { 796 int i; 797 798 ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4, 799 GFP_KERNEL, &ep->sync_dma); 800 if (!ep->syncbuf) 801 return -ENOMEM; 802 803 for (i = 0; i < SYNC_URBS; i++) { 804 struct snd_urb_ctx *u = &ep->urb[i]; 805 u->index = i; 806 u->ep = ep; 807 u->packets = 1; 808 u->urb = usb_alloc_urb(1, GFP_KERNEL); 809 if (!u->urb) 810 goto out_of_memory; 811 u->urb->transfer_buffer = ep->syncbuf + i * 4; 812 u->urb->transfer_dma = ep->sync_dma + i * 4; 813 u->urb->transfer_buffer_length = 4; 814 u->urb->pipe = ep->pipe; 815 u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; 816 u->urb->number_of_packets = 1; 817 u->urb->interval = 1 << ep->syncinterval; 818 u->urb->context = u; 819 u->urb->complete = snd_complete_urb; 820 } 821 822 ep->nurbs = SYNC_URBS; 823 824 return 0; 825 826 out_of_memory: 827 release_urbs(ep, 0); 828 return -ENOMEM; 829 } 830 831 /** 832 * snd_usb_endpoint_set_params: configure an snd_usb_endpoint 833 * 834 * @ep: the snd_usb_endpoint to configure 835 * @pcm_format: the audio fomat. 836 * @channels: the number of audio channels. 837 * @period_bytes: the number of bytes in one alsa period. 838 * @period_frames: the number of frames in one alsa period. 839 * @buffer_periods: the number of periods in one alsa buffer. 840 * @rate: the frame rate. 841 * @fmt: the USB audio format information 842 * @sync_ep: the sync endpoint to use, if any 843 * 844 * Determine the number of URBs to be used on this endpoint. 845 * An endpoint must be configured before it can be started. 846 * An endpoint that is already running can not be reconfigured. 847 */ 848 int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep, 849 snd_pcm_format_t pcm_format, 850 unsigned int channels, 851 unsigned int period_bytes, 852 unsigned int period_frames, 853 unsigned int buffer_periods, 854 unsigned int rate, 855 struct audioformat *fmt, 856 struct snd_usb_endpoint *sync_ep) 857 { 858 int err; 859 860 if (ep->use_count != 0) { 861 usb_audio_warn(ep->chip, 862 "Unable to change format on ep #%x: already in use\n", 863 ep->ep_num); 864 return -EBUSY; 865 } 866 867 /* release old buffers, if any */ 868 release_urbs(ep, 0); 869 870 ep->datainterval = fmt->datainterval; 871 ep->maxpacksize = fmt->maxpacksize; 872 ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX); 873 874 if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL) 875 ep->freqn = get_usb_full_speed_rate(rate); 876 else 877 ep->freqn = get_usb_high_speed_rate(rate); 878 879 /* calculate the frequency in 16.16 format */ 880 ep->freqm = ep->freqn; 881 ep->freqshift = INT_MIN; 882 883 ep->phase = 0; 884 885 switch (ep->type) { 886 case SND_USB_ENDPOINT_TYPE_DATA: 887 err = data_ep_set_params(ep, pcm_format, channels, 888 period_bytes, period_frames, 889 buffer_periods, fmt, sync_ep); 890 break; 891 case SND_USB_ENDPOINT_TYPE_SYNC: 892 err = sync_ep_set_params(ep); 893 break; 894 default: 895 err = -EINVAL; 896 } 897 898 usb_audio_dbg(ep->chip, 899 "Setting params for ep #%x (type %d, %d urbs), ret=%d\n", 900 ep->ep_num, ep->type, ep->nurbs, err); 901 902 return err; 903 } 904 905 /** 906 * snd_usb_endpoint_start: start an snd_usb_endpoint 907 * 908 * @ep: the endpoint to start 909 * 910 * A call to this function will increment the use count of the endpoint. 911 * In case it is not already running, the URBs for this endpoint will be 912 * submitted. Otherwise, this function does nothing. 913 * 914 * Must be balanced to calls of snd_usb_endpoint_stop(). 915 * 916 * Returns an error if the URB submission failed, 0 in all other cases. 917 */ 918 int snd_usb_endpoint_start(struct snd_usb_endpoint *ep) 919 { 920 int err; 921 unsigned int i; 922 923 if (atomic_read(&ep->chip->shutdown)) 924 return -EBADFD; 925 926 /* already running? */ 927 if (++ep->use_count != 1) 928 return 0; 929 930 /* just to be sure */ 931 deactivate_urbs(ep, false); 932 933 ep->active_mask = 0; 934 ep->unlink_mask = 0; 935 ep->phase = 0; 936 937 snd_usb_endpoint_start_quirk(ep); 938 939 /* 940 * If this endpoint has a data endpoint as implicit feedback source, 941 * don't start the urbs here. Instead, mark them all as available, 942 * wait for the record urbs to return and queue the playback urbs 943 * from that context. 944 */ 945 946 set_bit(EP_FLAG_RUNNING, &ep->flags); 947 948 if (snd_usb_endpoint_implicit_feedback_sink(ep)) { 949 for (i = 0; i < ep->nurbs; i++) { 950 struct snd_urb_ctx *ctx = ep->urb + i; 951 list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs); 952 } 953 954 return 0; 955 } 956 957 for (i = 0; i < ep->nurbs; i++) { 958 struct urb *urb = ep->urb[i].urb; 959 960 if (snd_BUG_ON(!urb)) 961 goto __error; 962 963 if (usb_pipeout(ep->pipe)) { 964 prepare_outbound_urb(ep, urb->context); 965 } else { 966 prepare_inbound_urb(ep, urb->context); 967 } 968 969 err = usb_submit_urb(urb, GFP_ATOMIC); 970 if (err < 0) { 971 usb_audio_err(ep->chip, 972 "cannot submit urb %d, error %d: %s\n", 973 i, err, usb_error_string(err)); 974 goto __error; 975 } 976 set_bit(i, &ep->active_mask); 977 } 978 979 return 0; 980 981 __error: 982 clear_bit(EP_FLAG_RUNNING, &ep->flags); 983 ep->use_count--; 984 deactivate_urbs(ep, false); 985 return -EPIPE; 986 } 987 988 /** 989 * snd_usb_endpoint_stop: stop an snd_usb_endpoint 990 * 991 * @ep: the endpoint to stop (may be NULL) 992 * 993 * A call to this function will decrement the use count of the endpoint. 994 * In case the last user has requested the endpoint stop, the URBs will 995 * actually be deactivated. 996 * 997 * Must be balanced to calls of snd_usb_endpoint_start(). 998 * 999 * The caller needs to synchronize the pending stop operation via 1000 * snd_usb_endpoint_sync_pending_stop(). 1001 */ 1002 void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep) 1003 { 1004 if (!ep) 1005 return; 1006 1007 if (snd_BUG_ON(ep->use_count == 0)) 1008 return; 1009 1010 if (--ep->use_count == 0) { 1011 deactivate_urbs(ep, false); 1012 set_bit(EP_FLAG_STOPPING, &ep->flags); 1013 } 1014 } 1015 1016 /** 1017 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint 1018 * 1019 * @ep: the endpoint to deactivate 1020 * 1021 * If the endpoint is not currently in use, this functions will 1022 * deactivate its associated URBs. 1023 * 1024 * In case of any active users, this functions does nothing. 1025 */ 1026 void snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep) 1027 { 1028 if (!ep) 1029 return; 1030 1031 if (ep->use_count != 0) 1032 return; 1033 1034 deactivate_urbs(ep, true); 1035 wait_clear_urbs(ep); 1036 } 1037 1038 /** 1039 * snd_usb_endpoint_release: Tear down an snd_usb_endpoint 1040 * 1041 * @ep: the endpoint to release 1042 * 1043 * This function does not care for the endpoint's use count but will tear 1044 * down all the streaming URBs immediately. 1045 */ 1046 void snd_usb_endpoint_release(struct snd_usb_endpoint *ep) 1047 { 1048 release_urbs(ep, 1); 1049 } 1050 1051 /** 1052 * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint 1053 * 1054 * @ep: the endpoint to free 1055 * 1056 * This free all resources of the given ep. 1057 */ 1058 void snd_usb_endpoint_free(struct snd_usb_endpoint *ep) 1059 { 1060 kfree(ep); 1061 } 1062 1063 /** 1064 * snd_usb_handle_sync_urb: parse an USB sync packet 1065 * 1066 * @ep: the endpoint to handle the packet 1067 * @sender: the sending endpoint 1068 * @urb: the received packet 1069 * 1070 * This function is called from the context of an endpoint that received 1071 * the packet and is used to let another endpoint object handle the payload. 1072 */ 1073 void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep, 1074 struct snd_usb_endpoint *sender, 1075 const struct urb *urb) 1076 { 1077 int shift; 1078 unsigned int f; 1079 unsigned long flags; 1080 1081 snd_BUG_ON(ep == sender); 1082 1083 /* 1084 * In case the endpoint is operating in implicit feedback mode, prepare 1085 * a new outbound URB that has the same layout as the received packet 1086 * and add it to the list of pending urbs. queue_pending_output_urbs() 1087 * will take care of them later. 1088 */ 1089 if (snd_usb_endpoint_implicit_feedback_sink(ep) && 1090 ep->use_count != 0) { 1091 1092 /* implicit feedback case */ 1093 int i, bytes = 0; 1094 struct snd_urb_ctx *in_ctx; 1095 struct snd_usb_packet_info *out_packet; 1096 1097 in_ctx = urb->context; 1098 1099 /* Count overall packet size */ 1100 for (i = 0; i < in_ctx->packets; i++) 1101 if (urb->iso_frame_desc[i].status == 0) 1102 bytes += urb->iso_frame_desc[i].actual_length; 1103 1104 /* 1105 * skip empty packets. At least M-Audio's Fast Track Ultra stops 1106 * streaming once it received a 0-byte OUT URB 1107 */ 1108 if (bytes == 0) 1109 return; 1110 1111 spin_lock_irqsave(&ep->lock, flags); 1112 out_packet = ep->next_packet + ep->next_packet_write_pos; 1113 1114 /* 1115 * Iterate through the inbound packet and prepare the lengths 1116 * for the output packet. The OUT packet we are about to send 1117 * will have the same amount of payload bytes per stride as the 1118 * IN packet we just received. Since the actual size is scaled 1119 * by the stride, use the sender stride to calculate the length 1120 * in case the number of channels differ between the implicitly 1121 * fed-back endpoint and the synchronizing endpoint. 1122 */ 1123 1124 out_packet->packets = in_ctx->packets; 1125 for (i = 0; i < in_ctx->packets; i++) { 1126 if (urb->iso_frame_desc[i].status == 0) 1127 out_packet->packet_size[i] = 1128 urb->iso_frame_desc[i].actual_length / sender->stride; 1129 else 1130 out_packet->packet_size[i] = 0; 1131 } 1132 1133 ep->next_packet_write_pos++; 1134 ep->next_packet_write_pos %= MAX_URBS; 1135 spin_unlock_irqrestore(&ep->lock, flags); 1136 queue_pending_output_urbs(ep); 1137 1138 return; 1139 } 1140 1141 /* 1142 * process after playback sync complete 1143 * 1144 * Full speed devices report feedback values in 10.14 format as samples 1145 * per frame, high speed devices in 16.16 format as samples per 1146 * microframe. 1147 * 1148 * Because the Audio Class 1 spec was written before USB 2.0, many high 1149 * speed devices use a wrong interpretation, some others use an 1150 * entirely different format. 1151 * 1152 * Therefore, we cannot predict what format any particular device uses 1153 * and must detect it automatically. 1154 */ 1155 1156 if (urb->iso_frame_desc[0].status != 0 || 1157 urb->iso_frame_desc[0].actual_length < 3) 1158 return; 1159 1160 f = le32_to_cpup(urb->transfer_buffer); 1161 if (urb->iso_frame_desc[0].actual_length == 3) 1162 f &= 0x00ffffff; 1163 else 1164 f &= 0x0fffffff; 1165 1166 if (f == 0) 1167 return; 1168 1169 if (unlikely(sender->tenor_fb_quirk)) { 1170 /* 1171 * Devices based on Tenor 8802 chipsets (TEAC UD-H01 1172 * and others) sometimes change the feedback value 1173 * by +/- 0x1.0000. 1174 */ 1175 if (f < ep->freqn - 0x8000) 1176 f += 0xf000; 1177 else if (f > ep->freqn + 0x8000) 1178 f -= 0xf000; 1179 } else if (unlikely(ep->freqshift == INT_MIN)) { 1180 /* 1181 * The first time we see a feedback value, determine its format 1182 * by shifting it left or right until it matches the nominal 1183 * frequency value. This assumes that the feedback does not 1184 * differ from the nominal value more than +50% or -25%. 1185 */ 1186 shift = 0; 1187 while (f < ep->freqn - ep->freqn / 4) { 1188 f <<= 1; 1189 shift++; 1190 } 1191 while (f > ep->freqn + ep->freqn / 2) { 1192 f >>= 1; 1193 shift--; 1194 } 1195 ep->freqshift = shift; 1196 } else if (ep->freqshift >= 0) 1197 f <<= ep->freqshift; 1198 else 1199 f >>= -ep->freqshift; 1200 1201 if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) { 1202 /* 1203 * If the frequency looks valid, set it. 1204 * This value is referred to in prepare_playback_urb(). 1205 */ 1206 spin_lock_irqsave(&ep->lock, flags); 1207 ep->freqm = f; 1208 spin_unlock_irqrestore(&ep->lock, flags); 1209 } else { 1210 /* 1211 * Out of range; maybe the shift value is wrong. 1212 * Reset it so that we autodetect again the next time. 1213 */ 1214 ep->freqshift = INT_MIN; 1215 } 1216 } 1217 1218