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