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 usb_audio_warn(chip, 601 "%u:%d : no or invalid class specific endpoint descriptor\n", 602 iface_no, altsd->bAlternateSetting); 603 return 0; 604 } 605 606 if (protocol == UAC_VERSION_1) { 607 attributes = csep->bmAttributes; 608 } else if (protocol == UAC_VERSION_2) { 609 struct uac2_iso_endpoint_descriptor *csep2 = 610 (struct uac2_iso_endpoint_descriptor *) csep; 611 612 attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX; 613 614 /* emulate the endpoint attributes of a v1 device */ 615 if (csep2->bmControls & UAC2_CONTROL_PITCH) 616 attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; 617 } else { /* UAC_VERSION_3 */ 618 struct uac3_iso_endpoint_descriptor *csep3 = 619 (struct uac3_iso_endpoint_descriptor *) csep; 620 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 629 /* find an input terminal descriptor (either UAC1 or UAC2) with the given 630 * terminal id 631 */ 632 static void * 633 snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface, 634 int terminal_id) 635 { 636 struct uac2_input_terminal_descriptor *term = NULL; 637 638 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 639 ctrl_iface->extralen, 640 term, UAC_INPUT_TERMINAL))) { 641 if (term->bTerminalID == terminal_id) 642 return term; 643 } 644 645 return NULL; 646 } 647 648 static void * 649 snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface, 650 int terminal_id) 651 { 652 /* OK to use with both UAC2 and UAC3 */ 653 struct uac2_output_terminal_descriptor *term = NULL; 654 655 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 656 ctrl_iface->extralen, 657 term, UAC_OUTPUT_TERMINAL))) { 658 if (term->bTerminalID == terminal_id) 659 return term; 660 } 661 662 return NULL; 663 } 664 665 static struct audioformat * 666 audio_format_alloc_init(struct snd_usb_audio *chip, 667 struct usb_host_interface *alts, 668 int protocol, int iface_no, int altset_idx, 669 int altno, int num_channels, int clock) 670 { 671 struct audioformat *fp; 672 673 fp = kzalloc(sizeof(*fp), GFP_KERNEL); 674 if (!fp) 675 return NULL; 676 677 fp->iface = iface_no; 678 fp->altsetting = altno; 679 fp->altset_idx = altset_idx; 680 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 681 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 682 fp->datainterval = snd_usb_parse_datainterval(chip, alts); 683 fp->protocol = protocol; 684 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 685 fp->channels = num_channels; 686 if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH) 687 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1) 688 * (fp->maxpacksize & 0x7ff); 689 fp->clock = clock; 690 INIT_LIST_HEAD(&fp->list); 691 692 return fp; 693 } 694 695 static struct audioformat * 696 snd_usb_get_audioformat_uac12(struct snd_usb_audio *chip, 697 struct usb_host_interface *alts, 698 int protocol, int iface_no, int altset_idx, 699 int altno, int stream, int bm_quirk) 700 { 701 struct usb_device *dev = chip->dev; 702 struct uac_format_type_i_continuous_descriptor *fmt; 703 unsigned int num_channels = 0, chconfig = 0; 704 struct audioformat *fp; 705 int clock = 0; 706 u64 format; 707 708 /* get audio formats */ 709 if (protocol == UAC_VERSION_1) { 710 struct uac1_as_header_descriptor *as = 711 snd_usb_find_csint_desc(alts->extra, alts->extralen, 712 NULL, UAC_AS_GENERAL); 713 struct uac_input_terminal_descriptor *iterm; 714 715 if (!as) { 716 dev_err(&dev->dev, 717 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 718 iface_no, altno); 719 return NULL; 720 } 721 722 if (as->bLength < sizeof(*as)) { 723 dev_err(&dev->dev, 724 "%u:%d : invalid UAC_AS_GENERAL desc\n", 725 iface_no, altno); 726 return NULL; 727 } 728 729 format = le16_to_cpu(as->wFormatTag); /* remember the format value */ 730 731 iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 732 as->bTerminalLink); 733 if (iterm) { 734 num_channels = iterm->bNrChannels; 735 chconfig = le16_to_cpu(iterm->wChannelConfig); 736 } 737 } else { /* UAC_VERSION_2 */ 738 struct uac2_input_terminal_descriptor *input_term; 739 struct uac2_output_terminal_descriptor *output_term; 740 struct uac2_as_header_descriptor *as = 741 snd_usb_find_csint_desc(alts->extra, alts->extralen, 742 NULL, UAC_AS_GENERAL); 743 744 if (!as) { 745 dev_err(&dev->dev, 746 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 747 iface_no, altno); 748 return NULL; 749 } 750 751 if (as->bLength < sizeof(*as)) { 752 dev_err(&dev->dev, 753 "%u:%d : invalid UAC_AS_GENERAL desc\n", 754 iface_no, altno); 755 return NULL; 756 } 757 758 num_channels = as->bNrChannels; 759 format = le32_to_cpu(as->bmFormats); 760 chconfig = le32_to_cpu(as->bmChannelConfig); 761 762 /* 763 * lookup the terminal associated to this interface 764 * to extract the clock 765 */ 766 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 767 as->bTerminalLink); 768 if (input_term) { 769 clock = input_term->bCSourceID; 770 if (!chconfig && (num_channels == input_term->bNrChannels)) 771 chconfig = le32_to_cpu(input_term->bmChannelConfig); 772 goto found_clock; 773 } 774 775 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, 776 as->bTerminalLink); 777 if (output_term) { 778 clock = output_term->bCSourceID; 779 goto found_clock; 780 } 781 782 dev_err(&dev->dev, 783 "%u:%d : bogus bTerminalLink %d\n", 784 iface_no, altno, as->bTerminalLink); 785 return NULL; 786 } 787 788 found_clock: 789 /* get format type */ 790 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, 791 NULL, UAC_FORMAT_TYPE); 792 if (!fmt) { 793 dev_err(&dev->dev, 794 "%u:%d : no UAC_FORMAT_TYPE desc\n", 795 iface_no, altno); 796 return NULL; 797 } 798 if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) 799 || ((protocol == UAC_VERSION_2) && 800 (fmt->bLength < 6))) { 801 dev_err(&dev->dev, 802 "%u:%d : invalid UAC_FORMAT_TYPE desc\n", 803 iface_no, altno); 804 return NULL; 805 } 806 807 /* 808 * Blue Microphones workaround: The last altsetting is 809 * identical with the previous one, except for a larger 810 * packet size, but is actually a mislabeled two-channel 811 * setting; ignore it. 812 * 813 * Part 2: analyze quirk flag and format 814 */ 815 if (bm_quirk && fmt->bNrChannels == 1 && fmt->bSubframeSize == 2) 816 return NULL; 817 818 fp = audio_format_alloc_init(chip, alts, protocol, iface_no, 819 altset_idx, altno, num_channels, clock); 820 if (!fp) 821 return ERR_PTR(-ENOMEM); 822 823 fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, 824 iface_no); 825 826 /* some quirks for attributes here */ 827 snd_usb_audioformat_attributes_quirk(chip, fp, stream); 828 829 /* ok, let's parse further... */ 830 if (snd_usb_parse_audio_format(chip, fp, format, 831 fmt, stream) < 0) { 832 kfree(fp->rate_table); 833 kfree(fp); 834 return NULL; 835 } 836 837 /* Create chmap */ 838 if (fp->channels != num_channels) 839 chconfig = 0; 840 841 fp->chmap = convert_chmap(fp->channels, chconfig, protocol); 842 843 return fp; 844 } 845 846 static struct audioformat * 847 snd_usb_get_audioformat_uac3(struct snd_usb_audio *chip, 848 struct usb_host_interface *alts, 849 struct snd_usb_power_domain **pd_out, 850 int iface_no, int altset_idx, 851 int altno, int stream) 852 { 853 struct usb_device *dev = chip->dev; 854 struct uac3_input_terminal_descriptor *input_term; 855 struct uac3_output_terminal_descriptor *output_term; 856 struct uac3_cluster_header_descriptor *cluster; 857 struct uac3_as_header_descriptor *as = NULL; 858 struct uac3_hc_descriptor_header hc_header; 859 struct snd_pcm_chmap_elem *chmap; 860 struct snd_usb_power_domain *pd; 861 unsigned char badd_profile; 862 u64 badd_formats = 0; 863 unsigned int num_channels; 864 struct audioformat *fp; 865 u16 cluster_id, wLength; 866 int clock = 0; 867 int err; 868 869 badd_profile = chip->badd_profile; 870 871 if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { 872 unsigned int maxpacksize = 873 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 874 875 switch (maxpacksize) { 876 default: 877 dev_err(&dev->dev, 878 "%u:%d : incorrect wMaxPacketSize for BADD profile\n", 879 iface_no, altno); 880 return NULL; 881 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_16: 882 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_16: 883 badd_formats = SNDRV_PCM_FMTBIT_S16_LE; 884 num_channels = 1; 885 break; 886 case UAC3_BADD_EP_MAXPSIZE_SYNC_MONO_24: 887 case UAC3_BADD_EP_MAXPSIZE_ASYNC_MONO_24: 888 badd_formats = SNDRV_PCM_FMTBIT_S24_3LE; 889 num_channels = 1; 890 break; 891 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_16: 892 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_16: 893 badd_formats = SNDRV_PCM_FMTBIT_S16_LE; 894 num_channels = 2; 895 break; 896 case UAC3_BADD_EP_MAXPSIZE_SYNC_STEREO_24: 897 case UAC3_BADD_EP_MAXPSIZE_ASYNC_STEREO_24: 898 badd_formats = SNDRV_PCM_FMTBIT_S24_3LE; 899 num_channels = 2; 900 break; 901 } 902 903 chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); 904 if (!chmap) 905 return ERR_PTR(-ENOMEM); 906 907 if (num_channels == 1) { 908 chmap->map[0] = SNDRV_CHMAP_MONO; 909 } else { 910 chmap->map[0] = SNDRV_CHMAP_FL; 911 chmap->map[1] = SNDRV_CHMAP_FR; 912 } 913 914 chmap->channels = num_channels; 915 clock = UAC3_BADD_CS_ID9; 916 goto found_clock; 917 } 918 919 as = snd_usb_find_csint_desc(alts->extra, alts->extralen, 920 NULL, UAC_AS_GENERAL); 921 if (!as) { 922 dev_err(&dev->dev, 923 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 924 iface_no, altno); 925 return NULL; 926 } 927 928 if (as->bLength < sizeof(*as)) { 929 dev_err(&dev->dev, 930 "%u:%d : invalid UAC_AS_GENERAL desc\n", 931 iface_no, altno); 932 return NULL; 933 } 934 935 cluster_id = le16_to_cpu(as->wClusterDescrID); 936 if (!cluster_id) { 937 dev_err(&dev->dev, 938 "%u:%d : no cluster descriptor\n", 939 iface_no, altno); 940 return NULL; 941 } 942 943 /* 944 * Get number of channels and channel map through 945 * High Capability Cluster Descriptor 946 * 947 * First step: get High Capability header and 948 * read size of Cluster Descriptor 949 */ 950 err = snd_usb_ctl_msg(chip->dev, 951 usb_rcvctrlpipe(chip->dev, 0), 952 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, 953 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 954 cluster_id, 955 snd_usb_ctrl_intf(chip), 956 &hc_header, sizeof(hc_header)); 957 if (err < 0) 958 return ERR_PTR(err); 959 else if (err != sizeof(hc_header)) { 960 dev_err(&dev->dev, 961 "%u:%d : can't get High Capability descriptor\n", 962 iface_no, altno); 963 return ERR_PTR(-EIO); 964 } 965 966 /* 967 * Second step: allocate needed amount of memory 968 * and request Cluster Descriptor 969 */ 970 wLength = le16_to_cpu(hc_header.wLength); 971 cluster = kzalloc(wLength, GFP_KERNEL); 972 if (!cluster) 973 return ERR_PTR(-ENOMEM); 974 err = snd_usb_ctl_msg(chip->dev, 975 usb_rcvctrlpipe(chip->dev, 0), 976 UAC3_CS_REQ_HIGH_CAPABILITY_DESCRIPTOR, 977 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, 978 cluster_id, 979 snd_usb_ctrl_intf(chip), 980 cluster, wLength); 981 if (err < 0) { 982 kfree(cluster); 983 return ERR_PTR(err); 984 } else if (err != wLength) { 985 dev_err(&dev->dev, 986 "%u:%d : can't get Cluster Descriptor\n", 987 iface_no, altno); 988 kfree(cluster); 989 return ERR_PTR(-EIO); 990 } 991 992 num_channels = cluster->bNrChannels; 993 chmap = convert_chmap_v3(cluster); 994 kfree(cluster); 995 996 /* 997 * lookup the terminal associated to this interface 998 * to extract the clock 999 */ 1000 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 1001 as->bTerminalLink); 1002 if (input_term) { 1003 clock = input_term->bCSourceID; 1004 goto found_clock; 1005 } 1006 1007 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, 1008 as->bTerminalLink); 1009 if (output_term) { 1010 clock = output_term->bCSourceID; 1011 goto found_clock; 1012 } 1013 1014 dev_err(&dev->dev, "%u:%d : bogus bTerminalLink %d\n", 1015 iface_no, altno, as->bTerminalLink); 1016 kfree(chmap); 1017 return NULL; 1018 1019 found_clock: 1020 fp = audio_format_alloc_init(chip, alts, UAC_VERSION_3, iface_no, 1021 altset_idx, altno, num_channels, clock); 1022 if (!fp) { 1023 kfree(chmap); 1024 return ERR_PTR(-ENOMEM); 1025 } 1026 1027 fp->chmap = chmap; 1028 1029 if (badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { 1030 fp->attributes = 0; /* No attributes */ 1031 1032 fp->fmt_type = UAC_FORMAT_TYPE_I; 1033 fp->formats = badd_formats; 1034 1035 fp->nr_rates = 0; /* SNDRV_PCM_RATE_CONTINUOUS */ 1036 fp->rate_min = UAC3_BADD_SAMPLING_RATE; 1037 fp->rate_max = UAC3_BADD_SAMPLING_RATE; 1038 fp->rates = SNDRV_PCM_RATE_CONTINUOUS; 1039 1040 pd = kzalloc(sizeof(*pd), GFP_KERNEL); 1041 if (!pd) { 1042 kfree(fp->rate_table); 1043 kfree(fp); 1044 return NULL; 1045 } 1046 pd->pd_id = (stream == SNDRV_PCM_STREAM_PLAYBACK) ? 1047 UAC3_BADD_PD_ID10 : UAC3_BADD_PD_ID11; 1048 pd->pd_d1d0_rec = UAC3_BADD_PD_RECOVER_D1D0; 1049 pd->pd_d2d0_rec = UAC3_BADD_PD_RECOVER_D2D0; 1050 1051 } else { 1052 fp->attributes = parse_uac_endpoint_attributes(chip, alts, 1053 UAC_VERSION_3, 1054 iface_no); 1055 1056 pd = snd_usb_find_power_domain(chip->ctrl_intf, 1057 as->bTerminalLink); 1058 1059 /* ok, let's parse further... */ 1060 if (snd_usb_parse_audio_format_v3(chip, fp, as, stream) < 0) { 1061 kfree(pd); 1062 kfree(fp->chmap); 1063 kfree(fp->rate_table); 1064 kfree(fp); 1065 return NULL; 1066 } 1067 } 1068 1069 if (pd) 1070 *pd_out = pd; 1071 1072 return fp; 1073 } 1074 1075 int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no) 1076 { 1077 struct usb_device *dev; 1078 struct usb_interface *iface; 1079 struct usb_host_interface *alts; 1080 struct usb_interface_descriptor *altsd; 1081 int i, altno, err, stream; 1082 struct audioformat *fp = NULL; 1083 struct snd_usb_power_domain *pd = NULL; 1084 int num, protocol; 1085 1086 dev = chip->dev; 1087 1088 /* parse the interface's altsettings */ 1089 iface = usb_ifnum_to_if(dev, iface_no); 1090 1091 num = iface->num_altsetting; 1092 1093 /* 1094 * Dallas DS4201 workaround: It presents 5 altsettings, but the last 1095 * one misses syncpipe, and does not produce any sound. 1096 */ 1097 if (chip->usb_id == USB_ID(0x04fa, 0x4201)) 1098 num = 4; 1099 1100 for (i = 0; i < num; i++) { 1101 alts = &iface->altsetting[i]; 1102 altsd = get_iface_desc(alts); 1103 protocol = altsd->bInterfaceProtocol; 1104 /* skip invalid one */ 1105 if (((altsd->bInterfaceClass != USB_CLASS_AUDIO || 1106 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING && 1107 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) && 1108 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 1109 altsd->bNumEndpoints < 1 || 1110 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0) 1111 continue; 1112 /* must be isochronous */ 1113 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 1114 USB_ENDPOINT_XFER_ISOC) 1115 continue; 1116 /* check direction */ 1117 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ? 1118 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 1119 altno = altsd->bAlternateSetting; 1120 1121 if (snd_usb_apply_interface_quirk(chip, iface_no, altno)) 1122 continue; 1123 1124 /* 1125 * Roland audio streaming interfaces are marked with protocols 1126 * 0/1/2, but are UAC 1 compatible. 1127 */ 1128 if (USB_ID_VENDOR(chip->usb_id) == 0x0582 && 1129 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC && 1130 protocol <= 2) 1131 protocol = UAC_VERSION_1; 1132 1133 switch (protocol) { 1134 default: 1135 dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n", 1136 iface_no, altno, protocol); 1137 protocol = UAC_VERSION_1; 1138 /* fall through */ 1139 case UAC_VERSION_1: 1140 /* fall through */ 1141 case UAC_VERSION_2: { 1142 int bm_quirk = 0; 1143 1144 /* 1145 * Blue Microphones workaround: The last altsetting is 1146 * identical with the previous one, except for a larger 1147 * packet size, but is actually a mislabeled two-channel 1148 * setting; ignore it. 1149 * 1150 * Part 1: prepare quirk flag 1151 */ 1152 if (altno == 2 && num == 3 && 1153 fp && fp->altsetting == 1 && fp->channels == 1 && 1154 fp->formats == SNDRV_PCM_FMTBIT_S16_LE && 1155 protocol == UAC_VERSION_1 && 1156 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 1157 fp->maxpacksize * 2) 1158 bm_quirk = 1; 1159 1160 fp = snd_usb_get_audioformat_uac12(chip, alts, protocol, 1161 iface_no, i, altno, 1162 stream, bm_quirk); 1163 break; 1164 } 1165 case UAC_VERSION_3: 1166 fp = snd_usb_get_audioformat_uac3(chip, alts, &pd, 1167 iface_no, i, altno, stream); 1168 break; 1169 } 1170 1171 if (!fp) 1172 continue; 1173 else if (IS_ERR(fp)) 1174 return PTR_ERR(fp); 1175 1176 dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint); 1177 if (protocol == UAC_VERSION_3) 1178 err = snd_usb_add_audio_stream_v3(chip, stream, fp, pd); 1179 else 1180 err = snd_usb_add_audio_stream(chip, stream, fp); 1181 1182 if (err < 0) { 1183 list_del(&fp->list); /* unlink for avoiding double-free */ 1184 kfree(pd); 1185 kfree(fp->rate_table); 1186 kfree(fp->chmap); 1187 kfree(fp); 1188 return err; 1189 } 1190 /* try to set the interface... */ 1191 usb_set_interface(chip->dev, iface_no, altno); 1192 snd_usb_init_pitch(chip, iface_no, alts, fp); 1193 snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max); 1194 } 1195 return 0; 1196 } 1197 1198