1 /* 2 * This program is free software; you can redistribute it and/or modify 3 * it under the terms of the GNU General Public License as published by 4 * the Free Software Foundation; either version 2 of the License, or 5 * (at your option) any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 15 */ 16 17 18 #include <linux/init.h> 19 #include <linux/slab.h> 20 #include <linux/usb.h> 21 #include <linux/usb/audio.h> 22 #include <linux/usb/audio-v2.h> 23 #include <linux/usb/audio-v3.h> 24 25 #include <sound/core.h> 26 #include <sound/pcm.h> 27 #include <sound/control.h> 28 #include <sound/tlv.h> 29 30 #include "usbaudio.h" 31 #include "card.h" 32 #include "proc.h" 33 #include "quirks.h" 34 #include "endpoint.h" 35 #include "pcm.h" 36 #include "helper.h" 37 #include "format.h" 38 #include "clock.h" 39 #include "stream.h" 40 #include "power.h" 41 42 /* 43 * free a substream 44 */ 45 static void free_substream(struct snd_usb_substream *subs) 46 { 47 struct audioformat *fp, *n; 48 49 if (!subs->num_formats) 50 return; /* not initialized */ 51 list_for_each_entry_safe(fp, n, &subs->fmt_list, list) { 52 kfree(fp->rate_table); 53 kfree(fp->chmap); 54 kfree(fp); 55 } 56 kfree(subs->rate_list.list); 57 kfree(subs->str_pd); 58 } 59 60 61 /* 62 * free a usb stream instance 63 */ 64 static void snd_usb_audio_stream_free(struct snd_usb_stream *stream) 65 { 66 free_substream(&stream->substream[0]); 67 free_substream(&stream->substream[1]); 68 list_del(&stream->list); 69 kfree(stream); 70 } 71 72 static void snd_usb_audio_pcm_free(struct snd_pcm *pcm) 73 { 74 struct snd_usb_stream *stream = pcm->private_data; 75 if (stream) { 76 stream->pcm = NULL; 77 snd_usb_audio_stream_free(stream); 78 } 79 } 80 81 /* 82 * initialize the substream instance. 83 */ 84 85 static void snd_usb_init_substream(struct snd_usb_stream *as, 86 int stream, 87 struct audioformat *fp, 88 struct snd_usb_power_domain *pd) 89 { 90 struct snd_usb_substream *subs = &as->substream[stream]; 91 92 INIT_LIST_HEAD(&subs->fmt_list); 93 spin_lock_init(&subs->lock); 94 95 subs->stream = as; 96 subs->direction = stream; 97 subs->dev = as->chip->dev; 98 subs->txfr_quirk = as->chip->txfr_quirk; 99 subs->tx_length_quirk = as->chip->tx_length_quirk; 100 subs->speed = snd_usb_get_speed(subs->dev); 101 subs->pkt_offset_adj = 0; 102 103 snd_usb_set_pcm_ops(as->pcm, stream); 104 105 list_add_tail(&fp->list, &subs->fmt_list); 106 subs->formats |= fp->formats; 107 subs->num_formats++; 108 subs->fmt_type = fp->fmt_type; 109 subs->ep_num = fp->endpoint; 110 if (fp->channels > subs->channels_max) 111 subs->channels_max = fp->channels; 112 113 if (pd) { 114 subs->str_pd = pd; 115 /* Initialize Power Domain to idle status D1 */ 116 snd_usb_power_domain_set(subs->stream->chip, pd, 117 UAC3_PD_STATE_D1); 118 } 119 120 snd_usb_preallocate_buffer(subs); 121 } 122 123 /* kctl callbacks for usb-audio channel maps */ 124 static int usb_chmap_ctl_info(struct snd_kcontrol *kcontrol, 125 struct snd_ctl_elem_info *uinfo) 126 { 127 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 128 struct snd_usb_substream *subs = info->private_data; 129 130 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 131 uinfo->count = subs->channels_max; 132 uinfo->value.integer.min = 0; 133 uinfo->value.integer.max = SNDRV_CHMAP_LAST; 134 return 0; 135 } 136 137 /* check whether a duplicated entry exists in the audiofmt list */ 138 static bool have_dup_chmap(struct snd_usb_substream *subs, 139 struct audioformat *fp) 140 { 141 struct audioformat *prev = fp; 142 143 list_for_each_entry_continue_reverse(prev, &subs->fmt_list, list) { 144 if (prev->chmap && 145 !memcmp(prev->chmap, fp->chmap, sizeof(*fp->chmap))) 146 return true; 147 } 148 return false; 149 } 150 151 static int usb_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag, 152 unsigned int size, unsigned int __user *tlv) 153 { 154 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 155 struct snd_usb_substream *subs = info->private_data; 156 struct audioformat *fp; 157 unsigned int __user *dst; 158 int count = 0; 159 160 if (size < 8) 161 return -ENOMEM; 162 if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv)) 163 return -EFAULT; 164 size -= 8; 165 dst = tlv + 2; 166 list_for_each_entry(fp, &subs->fmt_list, list) { 167 int i, ch_bytes; 168 169 if (!fp->chmap) 170 continue; 171 if (have_dup_chmap(subs, fp)) 172 continue; 173 /* copy the entry */ 174 ch_bytes = fp->chmap->channels * 4; 175 if (size < 8 + ch_bytes) 176 return -ENOMEM; 177 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) || 178 put_user(ch_bytes, dst + 1)) 179 return -EFAULT; 180 dst += 2; 181 for (i = 0; i < fp->chmap->channels; i++, dst++) { 182 if (put_user(fp->chmap->map[i], dst)) 183 return -EFAULT; 184 } 185 186 count += 8 + ch_bytes; 187 size -= 8 + ch_bytes; 188 } 189 if (put_user(count, tlv + 1)) 190 return -EFAULT; 191 return 0; 192 } 193 194 static int usb_chmap_ctl_get(struct snd_kcontrol *kcontrol, 195 struct snd_ctl_elem_value *ucontrol) 196 { 197 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 198 struct snd_usb_substream *subs = info->private_data; 199 struct snd_pcm_chmap_elem *chmap = NULL; 200 int i; 201 202 memset(ucontrol->value.integer.value, 0, 203 sizeof(ucontrol->value.integer.value)); 204 if (subs->cur_audiofmt) 205 chmap = subs->cur_audiofmt->chmap; 206 if (chmap) { 207 for (i = 0; i < chmap->channels; i++) 208 ucontrol->value.integer.value[i] = chmap->map[i]; 209 } 210 return 0; 211 } 212 213 /* create a chmap kctl assigned to the given USB substream */ 214 static int add_chmap(struct snd_pcm *pcm, int stream, 215 struct snd_usb_substream *subs) 216 { 217 struct audioformat *fp; 218 struct snd_pcm_chmap *chmap; 219 struct snd_kcontrol *kctl; 220 int err; 221 222 list_for_each_entry(fp, &subs->fmt_list, list) 223 if (fp->chmap) 224 goto ok; 225 /* no chmap is found */ 226 return 0; 227 228 ok: 229 err = snd_pcm_add_chmap_ctls(pcm, stream, NULL, 0, 0, &chmap); 230 if (err < 0) 231 return err; 232 233 /* override handlers */ 234 chmap->private_data = subs; 235 kctl = chmap->kctl; 236 kctl->info = usb_chmap_ctl_info; 237 kctl->get = usb_chmap_ctl_get; 238 kctl->tlv.c = usb_chmap_ctl_tlv; 239 240 return 0; 241 } 242 243 /* convert from USB ChannelConfig bits to ALSA chmap element */ 244 static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits, 245 int protocol) 246 { 247 static unsigned int uac1_maps[] = { 248 SNDRV_CHMAP_FL, /* left front */ 249 SNDRV_CHMAP_FR, /* right front */ 250 SNDRV_CHMAP_FC, /* center front */ 251 SNDRV_CHMAP_LFE, /* LFE */ 252 SNDRV_CHMAP_SL, /* left surround */ 253 SNDRV_CHMAP_SR, /* right surround */ 254 SNDRV_CHMAP_FLC, /* left of center */ 255 SNDRV_CHMAP_FRC, /* right of center */ 256 SNDRV_CHMAP_RC, /* surround */ 257 SNDRV_CHMAP_SL, /* side left */ 258 SNDRV_CHMAP_SR, /* side right */ 259 SNDRV_CHMAP_TC, /* top */ 260 0 /* terminator */ 261 }; 262 static unsigned int uac2_maps[] = { 263 SNDRV_CHMAP_FL, /* front left */ 264 SNDRV_CHMAP_FR, /* front right */ 265 SNDRV_CHMAP_FC, /* front center */ 266 SNDRV_CHMAP_LFE, /* LFE */ 267 SNDRV_CHMAP_RL, /* back left */ 268 SNDRV_CHMAP_RR, /* back right */ 269 SNDRV_CHMAP_FLC, /* front left of center */ 270 SNDRV_CHMAP_FRC, /* front right of center */ 271 SNDRV_CHMAP_RC, /* back center */ 272 SNDRV_CHMAP_SL, /* side left */ 273 SNDRV_CHMAP_SR, /* side right */ 274 SNDRV_CHMAP_TC, /* top center */ 275 SNDRV_CHMAP_TFL, /* top front left */ 276 SNDRV_CHMAP_TFC, /* top front center */ 277 SNDRV_CHMAP_TFR, /* top front right */ 278 SNDRV_CHMAP_TRL, /* top back left */ 279 SNDRV_CHMAP_TRC, /* top back center */ 280 SNDRV_CHMAP_TRR, /* top back right */ 281 SNDRV_CHMAP_TFLC, /* top front left of center */ 282 SNDRV_CHMAP_TFRC, /* top front right of center */ 283 SNDRV_CHMAP_LLFE, /* left LFE */ 284 SNDRV_CHMAP_RLFE, /* right LFE */ 285 SNDRV_CHMAP_TSL, /* top side left */ 286 SNDRV_CHMAP_TSR, /* top side right */ 287 SNDRV_CHMAP_BC, /* bottom center */ 288 SNDRV_CHMAP_RLC, /* back left of center */ 289 SNDRV_CHMAP_RRC, /* back right of center */ 290 0 /* terminator */ 291 }; 292 struct snd_pcm_chmap_elem *chmap; 293 const unsigned int *maps; 294 int c; 295 296 if (channels > ARRAY_SIZE(chmap->map)) 297 return NULL; 298 299 chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); 300 if (!chmap) 301 return NULL; 302 303 maps = protocol == UAC_VERSION_2 ? uac2_maps : uac1_maps; 304 chmap->channels = channels; 305 c = 0; 306 307 if (bits) { 308 for (; bits && *maps; maps++, bits >>= 1) 309 if (bits & 1) 310 chmap->map[c++] = *maps; 311 } else { 312 /* If we're missing wChannelConfig, then guess something 313 to make sure the channel map is not skipped entirely */ 314 if (channels == 1) 315 chmap->map[c++] = SNDRV_CHMAP_MONO; 316 else 317 for (; c < channels && *maps; maps++) 318 chmap->map[c++] = *maps; 319 } 320 321 for (; c < channels; c++) 322 chmap->map[c] = SNDRV_CHMAP_UNKNOWN; 323 324 return chmap; 325 } 326 327 /* UAC3 device stores channels information in Cluster Descriptors */ 328 static struct 329 snd_pcm_chmap_elem *convert_chmap_v3(struct uac3_cluster_header_descriptor 330 *cluster) 331 { 332 unsigned int channels = cluster->bNrChannels; 333 struct snd_pcm_chmap_elem *chmap; 334 void *p = cluster; 335 int len, c; 336 337 if (channels > ARRAY_SIZE(chmap->map)) 338 return NULL; 339 340 chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); 341 if (!chmap) 342 return NULL; 343 344 len = le16_to_cpu(cluster->wLength); 345 c = 0; 346 p += sizeof(struct uac3_cluster_header_descriptor); 347 348 while (((p - (void *)cluster) < len) && (c < channels)) { 349 struct uac3_cluster_segment_descriptor *cs_desc = p; 350 u16 cs_len; 351 u8 cs_type; 352 353 cs_len = le16_to_cpu(cs_desc->wLength); 354 cs_type = cs_desc->bSegmentType; 355 356 if (cs_type == UAC3_CHANNEL_INFORMATION) { 357 struct uac3_cluster_information_segment_descriptor *is = p; 358 unsigned char map; 359 360 /* 361 * TODO: this conversion is not complete, update it 362 * after adding UAC3 values to asound.h 363 */ 364 switch (is->bChRelationship) { 365 case UAC3_CH_MONO: 366 map = SNDRV_CHMAP_MONO; 367 break; 368 case UAC3_CH_LEFT: 369 case UAC3_CH_FRONT_LEFT: 370 case UAC3_CH_HEADPHONE_LEFT: 371 map = SNDRV_CHMAP_FL; 372 break; 373 case UAC3_CH_RIGHT: 374 case UAC3_CH_FRONT_RIGHT: 375 case UAC3_CH_HEADPHONE_RIGHT: 376 map = SNDRV_CHMAP_FR; 377 break; 378 case UAC3_CH_FRONT_CENTER: 379 map = SNDRV_CHMAP_FC; 380 break; 381 case UAC3_CH_FRONT_LEFT_OF_CENTER: 382 map = SNDRV_CHMAP_FLC; 383 break; 384 case UAC3_CH_FRONT_RIGHT_OF_CENTER: 385 map = SNDRV_CHMAP_FRC; 386 break; 387 case UAC3_CH_SIDE_LEFT: 388 map = SNDRV_CHMAP_SL; 389 break; 390 case UAC3_CH_SIDE_RIGHT: 391 map = SNDRV_CHMAP_SR; 392 break; 393 case UAC3_CH_BACK_LEFT: 394 map = SNDRV_CHMAP_RL; 395 break; 396 case UAC3_CH_BACK_RIGHT: 397 map = SNDRV_CHMAP_RR; 398 break; 399 case UAC3_CH_BACK_CENTER: 400 map = SNDRV_CHMAP_RC; 401 break; 402 case UAC3_CH_BACK_LEFT_OF_CENTER: 403 map = SNDRV_CHMAP_RLC; 404 break; 405 case UAC3_CH_BACK_RIGHT_OF_CENTER: 406 map = SNDRV_CHMAP_RRC; 407 break; 408 case UAC3_CH_TOP_CENTER: 409 map = SNDRV_CHMAP_TC; 410 break; 411 case UAC3_CH_TOP_FRONT_LEFT: 412 map = SNDRV_CHMAP_TFL; 413 break; 414 case UAC3_CH_TOP_FRONT_RIGHT: 415 map = SNDRV_CHMAP_TFR; 416 break; 417 case UAC3_CH_TOP_FRONT_CENTER: 418 map = SNDRV_CHMAP_TFC; 419 break; 420 case UAC3_CH_TOP_FRONT_LOC: 421 map = SNDRV_CHMAP_TFLC; 422 break; 423 case UAC3_CH_TOP_FRONT_ROC: 424 map = SNDRV_CHMAP_TFRC; 425 break; 426 case UAC3_CH_TOP_SIDE_LEFT: 427 map = SNDRV_CHMAP_TSL; 428 break; 429 case UAC3_CH_TOP_SIDE_RIGHT: 430 map = SNDRV_CHMAP_TSR; 431 break; 432 case UAC3_CH_TOP_BACK_LEFT: 433 map = SNDRV_CHMAP_TRL; 434 break; 435 case UAC3_CH_TOP_BACK_RIGHT: 436 map = SNDRV_CHMAP_TRR; 437 break; 438 case UAC3_CH_TOP_BACK_CENTER: 439 map = SNDRV_CHMAP_TRC; 440 break; 441 case UAC3_CH_BOTTOM_CENTER: 442 map = SNDRV_CHMAP_BC; 443 break; 444 case UAC3_CH_LOW_FREQUENCY_EFFECTS: 445 map = SNDRV_CHMAP_LFE; 446 break; 447 case UAC3_CH_LFE_LEFT: 448 map = SNDRV_CHMAP_LLFE; 449 break; 450 case UAC3_CH_LFE_RIGHT: 451 map = SNDRV_CHMAP_RLFE; 452 break; 453 case UAC3_CH_RELATIONSHIP_UNDEFINED: 454 default: 455 map = SNDRV_CHMAP_UNKNOWN; 456 break; 457 } 458 chmap->map[c++] = map; 459 } 460 p += cs_len; 461 } 462 463 if (channels < c) 464 pr_err("%s: channel number mismatch\n", __func__); 465 466 chmap->channels = channels; 467 468 for (; c < channels; c++) 469 chmap->map[c] = SNDRV_CHMAP_UNKNOWN; 470 471 return chmap; 472 } 473 474 /* 475 * add this endpoint to the chip instance. 476 * if a stream with the same endpoint already exists, append to it. 477 * if not, create a new pcm stream. note, fp is added to the substream 478 * fmt_list and will be freed on the chip instance release. do not free 479 * fp or do remove it from the substream fmt_list to avoid double-free. 480 */ 481 static int __snd_usb_add_audio_stream(struct snd_usb_audio *chip, 482 int stream, 483 struct audioformat *fp, 484 struct snd_usb_power_domain *pd) 485 486 { 487 struct snd_usb_stream *as; 488 struct snd_usb_substream *subs; 489 struct snd_pcm *pcm; 490 int err; 491 492 list_for_each_entry(as, &chip->pcm_list, list) { 493 if (as->fmt_type != fp->fmt_type) 494 continue; 495 subs = &as->substream[stream]; 496 if (subs->ep_num == fp->endpoint) { 497 list_add_tail(&fp->list, &subs->fmt_list); 498 subs->num_formats++; 499 subs->formats |= fp->formats; 500 return 0; 501 } 502 } 503 /* look for an empty stream */ 504 list_for_each_entry(as, &chip->pcm_list, list) { 505 if (as->fmt_type != fp->fmt_type) 506 continue; 507 subs = &as->substream[stream]; 508 if (subs->ep_num) 509 continue; 510 err = snd_pcm_new_stream(as->pcm, stream, 1); 511 if (err < 0) 512 return err; 513 snd_usb_init_substream(as, stream, fp, pd); 514 return add_chmap(as->pcm, stream, subs); 515 } 516 517 /* create a new pcm */ 518 as = kzalloc(sizeof(*as), GFP_KERNEL); 519 if (!as) 520 return -ENOMEM; 521 as->pcm_index = chip->pcm_devs; 522 as->chip = chip; 523 as->fmt_type = fp->fmt_type; 524 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs, 525 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0, 526 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1, 527 &pcm); 528 if (err < 0) { 529 kfree(as); 530 return err; 531 } 532 as->pcm = pcm; 533 pcm->private_data = as; 534 pcm->private_free = snd_usb_audio_pcm_free; 535 pcm->info_flags = 0; 536 if (chip->pcm_devs > 0) 537 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs); 538 else 539 strcpy(pcm->name, "USB Audio"); 540 541 snd_usb_init_substream(as, stream, fp, pd); 542 543 /* 544 * Keep using head insertion for M-Audio Audiophile USB (tm) which has a 545 * fix to swap capture stream order in conf/cards/USB-audio.conf 546 */ 547 if (chip->usb_id == USB_ID(0x0763, 0x2003)) 548 list_add(&as->list, &chip->pcm_list); 549 else 550 list_add_tail(&as->list, &chip->pcm_list); 551 552 chip->pcm_devs++; 553 554 snd_usb_proc_pcm_format_add(as); 555 556 return add_chmap(pcm, stream, &as->substream[stream]); 557 } 558 559 int snd_usb_add_audio_stream(struct snd_usb_audio *chip, 560 int stream, 561 struct audioformat *fp) 562 { 563 return __snd_usb_add_audio_stream(chip, stream, fp, NULL); 564 } 565 566 static int snd_usb_add_audio_stream_v3(struct snd_usb_audio *chip, 567 int stream, 568 struct audioformat *fp, 569 struct snd_usb_power_domain *pd) 570 { 571 return __snd_usb_add_audio_stream(chip, stream, fp, pd); 572 } 573 574 static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip, 575 struct usb_host_interface *alts, 576 int protocol, int iface_no) 577 { 578 /* parsed with a v1 header here. that's ok as we only look at the 579 * header first which is the same for both versions */ 580 struct uac_iso_endpoint_descriptor *csep; 581 struct usb_interface_descriptor *altsd = get_iface_desc(alts); 582 int attributes = 0; 583 584 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT); 585 586 /* Creamware Noah has this descriptor after the 2nd endpoint */ 587 if (!csep && altsd->bNumEndpoints >= 2) 588 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT); 589 590 /* 591 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra 592 * bytes after the first endpoint, go search the entire interface. 593 * Some devices have it directly *before* the standard endpoint. 594 */ 595 if (!csep) 596 csep = snd_usb_find_desc(alts->extra, alts->extralen, NULL, USB_DT_CS_ENDPOINT); 597 598 if (!csep || csep->bLength < 7 || 599 csep->bDescriptorSubtype != UAC_EP_GENERAL) 600 goto error; 601 602 if (protocol == UAC_VERSION_1) { 603 attributes = csep->bmAttributes; 604 } else if (protocol == UAC_VERSION_2) { 605 struct uac2_iso_endpoint_descriptor *csep2 = 606 (struct uac2_iso_endpoint_descriptor *) csep; 607 608 if (csep2->bLength < sizeof(*csep2)) 609 goto error; 610 attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX; 611 612 /* emulate the endpoint attributes of a v1 device */ 613 if (csep2->bmControls & UAC2_CONTROL_PITCH) 614 attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; 615 } else { /* UAC_VERSION_3 */ 616 struct uac3_iso_endpoint_descriptor *csep3 = 617 (struct uac3_iso_endpoint_descriptor *) csep; 618 619 if (csep3->bLength < sizeof(*csep3)) 620 goto error; 621 /* emulate the endpoint attributes of a v1 device */ 622 if (le32_to_cpu(csep3->bmControls) & UAC2_CONTROL_PITCH) 623 attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; 624 } 625 626 return attributes; 627 628 error: 629 usb_audio_warn(chip, 630 "%u:%d : no or invalid class specific endpoint descriptor\n", 631 iface_no, altsd->bAlternateSetting); 632 return 0; 633 } 634 635 /* find an input terminal descriptor (either UAC1 or UAC2) with the given 636 * terminal id 637 */ 638 static void * 639 snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface, 640 int terminal_id, bool uac23) 641 { 642 struct uac2_input_terminal_descriptor *term = NULL; 643 size_t minlen = uac23 ? sizeof(struct uac2_input_terminal_descriptor) : 644 sizeof(struct uac_input_terminal_descriptor); 645 646 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 647 ctrl_iface->extralen, 648 term, UAC_INPUT_TERMINAL))) { 649 if (term->bLength < minlen) 650 continue; 651 if (term->bTerminalID == terminal_id) 652 return term; 653 } 654 655 return NULL; 656 } 657 658 static void * 659 snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface, 660 int terminal_id) 661 { 662 /* OK to use with both UAC2 and UAC3 */ 663 struct uac2_output_terminal_descriptor *term = NULL; 664 665 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 666 ctrl_iface->extralen, 667 term, UAC_OUTPUT_TERMINAL))) { 668 if (term->bLength >= sizeof(*term) && 669 term->bTerminalID == terminal_id) 670 return term; 671 } 672 673 return NULL; 674 } 675 676 static struct audioformat * 677 audio_format_alloc_init(struct snd_usb_audio *chip, 678 struct usb_host_interface *alts, 679 int protocol, int iface_no, int altset_idx, 680 int altno, int num_channels, int clock) 681 { 682 struct audioformat *fp; 683 684 fp = kzalloc(sizeof(*fp), GFP_KERNEL); 685 if (!fp) 686 return NULL; 687 688 fp->iface = iface_no; 689 fp->altsetting = altno; 690 fp->altset_idx = altset_idx; 691 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 692 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 693 fp->datainterval = snd_usb_parse_datainterval(chip, alts); 694 fp->protocol = protocol; 695 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 696 fp->channels = num_channels; 697 if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH) 698 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1) 699 * (fp->maxpacksize & 0x7ff); 700 fp->clock = clock; 701 INIT_LIST_HEAD(&fp->list); 702 703 return fp; 704 } 705 706 static struct audioformat * 707 snd_usb_get_audioformat_uac12(struct snd_usb_audio *chip, 708 struct usb_host_interface *alts, 709 int protocol, int iface_no, int altset_idx, 710 int altno, int stream, int bm_quirk) 711 { 712 struct usb_device *dev = chip->dev; 713 struct uac_format_type_i_continuous_descriptor *fmt; 714 unsigned int num_channels = 0, chconfig = 0; 715 struct audioformat *fp; 716 int clock = 0; 717 u64 format; 718 719 /* get audio formats */ 720 if (protocol == UAC_VERSION_1) { 721 struct uac1_as_header_descriptor *as = 722 snd_usb_find_csint_desc(alts->extra, alts->extralen, 723 NULL, UAC_AS_GENERAL); 724 struct uac_input_terminal_descriptor *iterm; 725 726 if (!as) { 727 dev_err(&dev->dev, 728 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 729 iface_no, altno); 730 return NULL; 731 } 732 733 if (as->bLength < sizeof(*as)) { 734 dev_err(&dev->dev, 735 "%u:%d : invalid UAC_AS_GENERAL desc\n", 736 iface_no, altno); 737 return NULL; 738 } 739 740 format = le16_to_cpu(as->wFormatTag); /* remember the format value */ 741 742 iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 743 as->bTerminalLink, 744 false); 745 if (iterm) { 746 num_channels = iterm->bNrChannels; 747 chconfig = le16_to_cpu(iterm->wChannelConfig); 748 } 749 } else { /* UAC_VERSION_2 */ 750 struct uac2_input_terminal_descriptor *input_term; 751 struct uac2_output_terminal_descriptor *output_term; 752 struct uac2_as_header_descriptor *as = 753 snd_usb_find_csint_desc(alts->extra, alts->extralen, 754 NULL, UAC_AS_GENERAL); 755 756 if (!as) { 757 dev_err(&dev->dev, 758 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 759 iface_no, altno); 760 return NULL; 761 } 762 763 if (as->bLength < sizeof(*as)) { 764 dev_err(&dev->dev, 765 "%u:%d : invalid UAC_AS_GENERAL desc\n", 766 iface_no, altno); 767 return NULL; 768 } 769 770 num_channels = as->bNrChannels; 771 format = le32_to_cpu(as->bmFormats); 772 chconfig = le32_to_cpu(as->bmChannelConfig); 773 774 /* 775 * lookup the terminal associated to this interface 776 * to extract the clock 777 */ 778 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 779 as->bTerminalLink, 780 true); 781 if (input_term) { 782 clock = input_term->bCSourceID; 783 if (!chconfig && (num_channels == input_term->bNrChannels)) 784 chconfig = le32_to_cpu(input_term->bmChannelConfig); 785 goto found_clock; 786 } 787 788 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, 789 as->bTerminalLink); 790 if (output_term) { 791 clock = output_term->bCSourceID; 792 goto found_clock; 793 } 794 795 dev_err(&dev->dev, 796 "%u:%d : bogus bTerminalLink %d\n", 797 iface_no, altno, as->bTerminalLink); 798 return NULL; 799 } 800 801 found_clock: 802 /* get format type */ 803 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, 804 NULL, UAC_FORMAT_TYPE); 805 if (!fmt) { 806 dev_err(&dev->dev, 807 "%u:%d : no UAC_FORMAT_TYPE desc\n", 808 iface_no, altno); 809 return NULL; 810 } 811 if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) 812 || ((protocol == UAC_VERSION_2) && 813 (fmt->bLength < 6))) { 814 dev_err(&dev->dev, 815 "%u:%d : invalid UAC_FORMAT_TYPE desc\n", 816 iface_no, altno); 817 return NULL; 818 } 819 820 /* 821 * Blue Microphones workaround: The last altsetting is 822 * identical with the previous one, except for a larger 823 * packet size, but is actually a mislabeled two-channel 824 * setting; ignore it. 825 * 826 * Part 2: analyze quirk flag and format 827 */ 828 if (bm_quirk && fmt->bNrChannels == 1 && fmt->bSubframeSize == 2) 829 return NULL; 830 831 fp = audio_format_alloc_init(chip, alts, protocol, iface_no, 832 altset_idx, altno, num_channels, clock); 833 if (!fp) 834 return ERR_PTR(-ENOMEM); 835 836 fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, 837 iface_no); 838 839 /* some quirks for attributes here */ 840 snd_usb_audioformat_attributes_quirk(chip, fp, stream); 841 842 /* ok, let's parse further... */ 843 if (snd_usb_parse_audio_format(chip, fp, format, 844 fmt, stream) < 0) { 845 kfree(fp->rate_table); 846 kfree(fp); 847 return NULL; 848 } 849 850 /* Create chmap */ 851 if (fp->channels != num_channels) 852 chconfig = 0; 853 854 fp->chmap = convert_chmap(fp->channels, chconfig, protocol); 855 856 return fp; 857 } 858 859 static struct audioformat * 860 snd_usb_get_audioformat_uac3(struct snd_usb_audio *chip, 861 struct usb_host_interface *alts, 862 struct snd_usb_power_domain **pd_out, 863 int iface_no, int altset_idx, 864 int altno, int stream) 865 { 866 struct usb_device *dev = chip->dev; 867 struct uac3_input_terminal_descriptor *input_term; 868 struct uac3_output_terminal_descriptor *output_term; 869 struct uac3_cluster_header_descriptor *cluster; 870 struct uac3_as_header_descriptor *as = NULL; 871 struct uac3_hc_descriptor_header hc_header; 872 struct snd_pcm_chmap_elem *chmap; 873 struct snd_usb_power_domain *pd; 874 unsigned char badd_profile; 875 u64 badd_formats = 0; 876 unsigned int num_channels; 877 struct audioformat *fp; 878 u16 cluster_id, wLength; 879 int clock = 0; 880 int err; 881 882 badd_profile = chip->badd_profile; 883 884 if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { 885 unsigned int maxpacksize = 886 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 887 888 switch (maxpacksize) { 889 default: 890 dev_err(&dev->dev, 891 "%u:%d : incorrect wMaxPacketSize for BADD profile\n", 892 iface_no, altno); 893 return NULL; 894 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16: 895 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16: 896 badd_formats = SNDRV_PCM_FMTBIT_S16_LE; 897 num_channels = 1; 898 break; 899 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24: 900 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24: 901 badd_formats = SNDRV_PCM_FMTBIT_S24_3LE; 902 num_channels = 1; 903 break; 904 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16: 905 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16: 906 badd_formats = SNDRV_PCM_FMTBIT_S16_LE; 907 num_channels = 2; 908 break; 909 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24: 910 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24: 911 badd_formats = SNDRV_PCM_FMTBIT_S24_3LE; 912 num_channels = 2; 913 break; 914 } 915 916 chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); 917 if (!chmap) 918 return ERR_PTR(-ENOMEM); 919 920 if (num_channels == 1) { 921 chmap->map[0] = SNDRV_CHMAP_MONO; 922 } else { 923 chmap->map[0] = SNDRV_CHMAP_FL; 924 chmap->map[1] = SNDRV_CHMAP_FR; 925 } 926 927 chmap->channels = num_channels; 928 clock = UAC3_BADD_CS_ID9; 929 goto found_clock; 930 } 931 932 as = snd_usb_find_csint_desc(alts->extra, alts->extralen, 933 NULL, UAC_AS_GENERAL); 934 if (!as) { 935 dev_err(&dev->dev, 936 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 937 iface_no, altno); 938 return NULL; 939 } 940 941 if (as->bLength < sizeof(*as)) { 942 dev_err(&dev->dev, 943 "%u:%d : invalid UAC_AS_GENERAL desc\n", 944 iface_no, altno); 945 return NULL; 946 } 947 948 cluster_id = le16_to_cpu(as->wClusterDescrID); 949 if (!cluster_id) { 950 dev_err(&dev->dev, 951 "%u:%d : no cluster descriptor\n", 952 iface_no, altno); 953 return NULL; 954 } 955 956 /* 957 * Get number of channels and channel map through 958 * High Capability Cluster Descriptor 959 * 960 * First step: get High Capability header and 961 * read size of Cluster Descriptor 962 */ 963 err = snd_usb_ctl_msg(chip->dev, 964 usb_rcvctrlpipe(chip->dev, 0), 965 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, 966 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 967 cluster_id, 968 snd_usb_ctrl_intf(chip), 969 &hc_header, sizeof(hc_header)); 970 if (err < 0) 971 return ERR_PTR(err); 972 else if (err != sizeof(hc_header)) { 973 dev_err(&dev->dev, 974 "%u:%d : can't get High Capability descriptor\n", 975 iface_no, altno); 976 return ERR_PTR(-EIO); 977 } 978 979 /* 980 * Second step: allocate needed amount of memory 981 * and request Cluster Descriptor 982 */ 983 wLength = le16_to_cpu(hc_header.wLength); 984 cluster = kzalloc(wLength, GFP_KERNEL); 985 if (!cluster) 986 return ERR_PTR(-ENOMEM); 987 err = snd_usb_ctl_msg(chip->dev, 988 usb_rcvctrlpipe(chip->dev, 0), 989 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, 990 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 991 cluster_id, 992 snd_usb_ctrl_intf(chip), 993 cluster, wLength); 994 if (err < 0) { 995 kfree(cluster); 996 return ERR_PTR(err); 997 } else if (err != wLength) { 998 dev_err(&dev->dev, 999 "%u:%d : can't get Cluster Descriptor\n", 1000 iface_no, altno); 1001 kfree(cluster); 1002 return ERR_PTR(-EIO); 1003 } 1004 1005 num_channels = cluster->bNrChannels; 1006 chmap = convert_chmap_v3(cluster); 1007 kfree(cluster); 1008 1009 /* 1010 * lookup the terminal associated to this interface 1011 * to extract the clock 1012 */ 1013 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 1014 as->bTerminalLink, 1015 true); 1016 if (input_term) { 1017 clock = input_term->bCSourceID; 1018 goto found_clock; 1019 } 1020 1021 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, 1022 as->bTerminalLink); 1023 if (output_term) { 1024 clock = output_term->bCSourceID; 1025 goto found_clock; 1026 } 1027 1028 dev_err(&dev->dev, "%u:%d : bogus bTerminalLink %d\n", 1029 iface_no, altno, as->bTerminalLink); 1030 kfree(chmap); 1031 return NULL; 1032 1033 found_clock: 1034 fp = audio_format_alloc_init(chip, alts, UAC_VERSION_3, iface_no, 1035 altset_idx, altno, num_channels, clock); 1036 if (!fp) { 1037 kfree(chmap); 1038 return ERR_PTR(-ENOMEM); 1039 } 1040 1041 fp->chmap = chmap; 1042 1043 if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { 1044 fp->attributes = 0; /* No attributes */ 1045 1046 fp->fmt_type = UAC_FORMAT_TYPE_I; 1047 fp->formats = badd_formats; 1048 1049 fp->nr_rates = 0; /* SNDRV_PCM_RATE_CONTINUOUS */ 1050 fp->rate_min = UAC3_BADD_SAMPLING_RATE; 1051 fp->rate_max = UAC3_BADD_SAMPLING_RATE; 1052 fp->rates = SNDRV_PCM_RATE_CONTINUOUS; 1053 1054 pd = kzalloc(sizeof(*pd), GFP_KERNEL); 1055 if (!pd) { 1056 kfree(fp->rate_table); 1057 kfree(fp); 1058 return NULL; 1059 } 1060 pd->pd_id = (stream == SNDRV_PCM_STREAM_PLAYBACK) ? 1061 UAC3_BADD_PD_ID10 : UAC3_BADD_PD_ID11; 1062 pd->pd_d1d0_rec = UAC3_BADD_PD_RECOVER_D1D0; 1063 pd->pd_d2d0_rec = UAC3_BADD_PD_RECOVER_D2D0; 1064 1065 } else { 1066 fp->attributes = parse_uac_endpoint_attributes(chip, alts, 1067 UAC_VERSION_3, 1068 iface_no); 1069 1070 pd = snd_usb_find_power_domain(chip->ctrl_intf, 1071 as->bTerminalLink); 1072 1073 /* ok, let's parse further... */ 1074 if (snd_usb_parse_audio_format_v3(chip, fp, as, stream) < 0) { 1075 kfree(pd); 1076 kfree(fp->chmap); 1077 kfree(fp->rate_table); 1078 kfree(fp); 1079 return NULL; 1080 } 1081 } 1082 1083 if (pd) 1084 *pd_out = pd; 1085 1086 return fp; 1087 } 1088 1089 int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no) 1090 { 1091 struct usb_device *dev; 1092 struct usb_interface *iface; 1093 struct usb_host_interface *alts; 1094 struct usb_interface_descriptor *altsd; 1095 int i, altno, err, stream; 1096 struct audioformat *fp = NULL; 1097 struct snd_usb_power_domain *pd = NULL; 1098 int num, protocol; 1099 1100 dev = chip->dev; 1101 1102 /* parse the interface's altsettings */ 1103 iface = usb_ifnum_to_if(dev, iface_no); 1104 1105 num = iface->num_altsetting; 1106 1107 /* 1108 * Dallas DS4201 workaround: It presents 5 altsettings, but the last 1109 * one misses syncpipe, and does not produce any sound. 1110 */ 1111 if (chip->usb_id == USB_ID(0x04fa, 0x4201)) 1112 num = 4; 1113 1114 for (i = 0; i < num; i++) { 1115 alts = &iface->altsetting[i]; 1116 altsd = get_iface_desc(alts); 1117 protocol = altsd->bInterfaceProtocol; 1118 /* skip invalid one */ 1119 if (((altsd->bInterfaceClass != USB_CLASS_AUDIO || 1120 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING && 1121 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) && 1122 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 1123 altsd->bNumEndpoints < 1 || 1124 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0) 1125 continue; 1126 /* must be isochronous */ 1127 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 1128 USB_ENDPOINT_XFER_ISOC) 1129 continue; 1130 /* check direction */ 1131 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ? 1132 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 1133 altno = altsd->bAlternateSetting; 1134 1135 if (snd_usb_apply_interface_quirk(chip, iface_no, altno)) 1136 continue; 1137 1138 /* 1139 * Roland audio streaming interfaces are marked with protocols 1140 * 0/1/2, but are UAC 1 compatible. 1141 */ 1142 if (USB_ID_VENDOR(chip->usb_id) == 0x0582 && 1143 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC && 1144 protocol <= 2) 1145 protocol = UAC_VERSION_1; 1146 1147 switch (protocol) { 1148 default: 1149 dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n", 1150 iface_no, altno, protocol); 1151 protocol = UAC_VERSION_1; 1152 /* fall through */ 1153 case UAC_VERSION_1: 1154 /* fall through */ 1155 case UAC_VERSION_2: { 1156 int bm_quirk = 0; 1157 1158 /* 1159 * Blue Microphones workaround: The last altsetting is 1160 * identical with the previous one, except for a larger 1161 * packet size, but is actually a mislabeled two-channel 1162 * setting; ignore it. 1163 * 1164 * Part 1: prepare quirk flag 1165 */ 1166 if (altno == 2 && num == 3 && 1167 fp && fp->altsetting == 1 && fp->channels == 1 && 1168 fp->formats == SNDRV_PCM_FMTBIT_S16_LE && 1169 protocol == UAC_VERSION_1 && 1170 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 1171 fp->maxpacksize * 2) 1172 bm_quirk = 1; 1173 1174 fp = snd_usb_get_audioformat_uac12(chip, alts, protocol, 1175 iface_no, i, altno, 1176 stream, bm_quirk); 1177 break; 1178 } 1179 case UAC_VERSION_3: 1180 fp = snd_usb_get_audioformat_uac3(chip, alts, &pd, 1181 iface_no, i, altno, stream); 1182 break; 1183 } 1184 1185 if (!fp) 1186 continue; 1187 else if (IS_ERR(fp)) 1188 return PTR_ERR(fp); 1189 1190 dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint); 1191 if (protocol == UAC_VERSION_3) 1192 err = snd_usb_add_audio_stream_v3(chip, stream, fp, pd); 1193 else 1194 err = snd_usb_add_audio_stream(chip, stream, fp); 1195 1196 if (err < 0) { 1197 list_del(&fp->list); /* unlink for avoiding double-free */ 1198 kfree(pd); 1199 kfree(fp->rate_table); 1200 kfree(fp->chmap); 1201 kfree(fp); 1202 return err; 1203 } 1204 /* try to set the interface... */ 1205 usb_set_interface(chip->dev, iface_no, altno); 1206 snd_usb_init_pitch(chip, iface_no, alts, fp); 1207 snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max); 1208 } 1209 return 0; 1210 } 1211 1212