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 24 #include <sound/core.h> 25 #include <sound/pcm.h> 26 #include <sound/control.h> 27 #include <sound/tlv.h> 28 29 #include "usbaudio.h" 30 #include "card.h" 31 #include "proc.h" 32 #include "quirks.h" 33 #include "endpoint.h" 34 #include "pcm.h" 35 #include "helper.h" 36 #include "format.h" 37 #include "clock.h" 38 #include "stream.h" 39 40 /* 41 * free a substream 42 */ 43 static void free_substream(struct snd_usb_substream *subs) 44 { 45 struct audioformat *fp, *n; 46 47 if (!subs->num_formats) 48 return; /* not initialized */ 49 list_for_each_entry_safe(fp, n, &subs->fmt_list, list) { 50 kfree(fp->rate_table); 51 kfree(fp->chmap); 52 kfree(fp); 53 } 54 kfree(subs->rate_list.list); 55 } 56 57 58 /* 59 * free a usb stream instance 60 */ 61 static void snd_usb_audio_stream_free(struct snd_usb_stream *stream) 62 { 63 free_substream(&stream->substream[0]); 64 free_substream(&stream->substream[1]); 65 list_del(&stream->list); 66 kfree(stream); 67 } 68 69 static void snd_usb_audio_pcm_free(struct snd_pcm *pcm) 70 { 71 struct snd_usb_stream *stream = pcm->private_data; 72 if (stream) { 73 stream->pcm = NULL; 74 snd_usb_audio_stream_free(stream); 75 } 76 } 77 78 /* 79 * initialize the substream instance. 80 */ 81 82 static void snd_usb_init_substream(struct snd_usb_stream *as, 83 int stream, 84 struct audioformat *fp) 85 { 86 struct snd_usb_substream *subs = &as->substream[stream]; 87 88 INIT_LIST_HEAD(&subs->fmt_list); 89 spin_lock_init(&subs->lock); 90 91 subs->stream = as; 92 subs->direction = stream; 93 subs->dev = as->chip->dev; 94 subs->txfr_quirk = as->chip->txfr_quirk; 95 subs->tx_length_quirk = as->chip->tx_length_quirk; 96 subs->speed = snd_usb_get_speed(subs->dev); 97 subs->pkt_offset_adj = 0; 98 99 snd_usb_set_pcm_ops(as->pcm, stream); 100 101 list_add_tail(&fp->list, &subs->fmt_list); 102 subs->formats |= fp->formats; 103 subs->num_formats++; 104 subs->fmt_type = fp->fmt_type; 105 subs->ep_num = fp->endpoint; 106 if (fp->channels > subs->channels_max) 107 subs->channels_max = fp->channels; 108 } 109 110 /* kctl callbacks for usb-audio channel maps */ 111 static int usb_chmap_ctl_info(struct snd_kcontrol *kcontrol, 112 struct snd_ctl_elem_info *uinfo) 113 { 114 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 115 struct snd_usb_substream *subs = info->private_data; 116 117 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 118 uinfo->count = subs->channels_max; 119 uinfo->value.integer.min = 0; 120 uinfo->value.integer.max = SNDRV_CHMAP_LAST; 121 return 0; 122 } 123 124 /* check whether a duplicated entry exists in the audiofmt list */ 125 static bool have_dup_chmap(struct snd_usb_substream *subs, 126 struct audioformat *fp) 127 { 128 struct audioformat *prev = fp; 129 130 list_for_each_entry_continue_reverse(prev, &subs->fmt_list, list) { 131 if (prev->chmap && 132 !memcmp(prev->chmap, fp->chmap, sizeof(*fp->chmap))) 133 return true; 134 } 135 return false; 136 } 137 138 static int usb_chmap_ctl_tlv(struct snd_kcontrol *kcontrol, int op_flag, 139 unsigned int size, unsigned int __user *tlv) 140 { 141 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 142 struct snd_usb_substream *subs = info->private_data; 143 struct audioformat *fp; 144 unsigned int __user *dst; 145 int count = 0; 146 147 if (size < 8) 148 return -ENOMEM; 149 if (put_user(SNDRV_CTL_TLVT_CONTAINER, tlv)) 150 return -EFAULT; 151 size -= 8; 152 dst = tlv + 2; 153 list_for_each_entry(fp, &subs->fmt_list, list) { 154 int i, ch_bytes; 155 156 if (!fp->chmap) 157 continue; 158 if (have_dup_chmap(subs, fp)) 159 continue; 160 /* copy the entry */ 161 ch_bytes = fp->chmap->channels * 4; 162 if (size < 8 + ch_bytes) 163 return -ENOMEM; 164 if (put_user(SNDRV_CTL_TLVT_CHMAP_FIXED, dst) || 165 put_user(ch_bytes, dst + 1)) 166 return -EFAULT; 167 dst += 2; 168 for (i = 0; i < fp->chmap->channels; i++, dst++) { 169 if (put_user(fp->chmap->map[i], dst)) 170 return -EFAULT; 171 } 172 173 count += 8 + ch_bytes; 174 size -= 8 + ch_bytes; 175 } 176 if (put_user(count, tlv + 1)) 177 return -EFAULT; 178 return 0; 179 } 180 181 static int usb_chmap_ctl_get(struct snd_kcontrol *kcontrol, 182 struct snd_ctl_elem_value *ucontrol) 183 { 184 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 185 struct snd_usb_substream *subs = info->private_data; 186 struct snd_pcm_chmap_elem *chmap = NULL; 187 int i; 188 189 memset(ucontrol->value.integer.value, 0, 190 sizeof(ucontrol->value.integer.value)); 191 if (subs->cur_audiofmt) 192 chmap = subs->cur_audiofmt->chmap; 193 if (chmap) { 194 for (i = 0; i < chmap->channels; i++) 195 ucontrol->value.integer.value[i] = chmap->map[i]; 196 } 197 return 0; 198 } 199 200 /* create a chmap kctl assigned to the given USB substream */ 201 static int add_chmap(struct snd_pcm *pcm, int stream, 202 struct snd_usb_substream *subs) 203 { 204 struct audioformat *fp; 205 struct snd_pcm_chmap *chmap; 206 struct snd_kcontrol *kctl; 207 int err; 208 209 list_for_each_entry(fp, &subs->fmt_list, list) 210 if (fp->chmap) 211 goto ok; 212 /* no chmap is found */ 213 return 0; 214 215 ok: 216 err = snd_pcm_add_chmap_ctls(pcm, stream, NULL, 0, 0, &chmap); 217 if (err < 0) 218 return err; 219 220 /* override handlers */ 221 chmap->private_data = subs; 222 kctl = chmap->kctl; 223 kctl->info = usb_chmap_ctl_info; 224 kctl->get = usb_chmap_ctl_get; 225 kctl->tlv.c = usb_chmap_ctl_tlv; 226 227 return 0; 228 } 229 230 /* convert from USB ChannelConfig bits to ALSA chmap element */ 231 static struct snd_pcm_chmap_elem *convert_chmap(int channels, unsigned int bits, 232 int protocol) 233 { 234 static unsigned int uac1_maps[] = { 235 SNDRV_CHMAP_FL, /* left front */ 236 SNDRV_CHMAP_FR, /* right front */ 237 SNDRV_CHMAP_FC, /* center front */ 238 SNDRV_CHMAP_LFE, /* LFE */ 239 SNDRV_CHMAP_SL, /* left surround */ 240 SNDRV_CHMAP_SR, /* right surround */ 241 SNDRV_CHMAP_FLC, /* left of center */ 242 SNDRV_CHMAP_FRC, /* right of center */ 243 SNDRV_CHMAP_RC, /* surround */ 244 SNDRV_CHMAP_SL, /* side left */ 245 SNDRV_CHMAP_SR, /* side right */ 246 SNDRV_CHMAP_TC, /* top */ 247 0 /* terminator */ 248 }; 249 static unsigned int uac2_maps[] = { 250 SNDRV_CHMAP_FL, /* front left */ 251 SNDRV_CHMAP_FR, /* front right */ 252 SNDRV_CHMAP_FC, /* front center */ 253 SNDRV_CHMAP_LFE, /* LFE */ 254 SNDRV_CHMAP_RL, /* back left */ 255 SNDRV_CHMAP_RR, /* back right */ 256 SNDRV_CHMAP_FLC, /* front left of center */ 257 SNDRV_CHMAP_FRC, /* front right of center */ 258 SNDRV_CHMAP_RC, /* back center */ 259 SNDRV_CHMAP_SL, /* side left */ 260 SNDRV_CHMAP_SR, /* side right */ 261 SNDRV_CHMAP_TC, /* top center */ 262 SNDRV_CHMAP_TFL, /* top front left */ 263 SNDRV_CHMAP_TFC, /* top front center */ 264 SNDRV_CHMAP_TFR, /* top front right */ 265 SNDRV_CHMAP_TRL, /* top back left */ 266 SNDRV_CHMAP_TRC, /* top back center */ 267 SNDRV_CHMAP_TRR, /* top back right */ 268 SNDRV_CHMAP_TFLC, /* top front left of center */ 269 SNDRV_CHMAP_TFRC, /* top front right of center */ 270 SNDRV_CHMAP_LLFE, /* left LFE */ 271 SNDRV_CHMAP_RLFE, /* right LFE */ 272 SNDRV_CHMAP_TSL, /* top side left */ 273 SNDRV_CHMAP_TSR, /* top side right */ 274 SNDRV_CHMAP_BC, /* bottom center */ 275 SNDRV_CHMAP_RLC, /* back left of center */ 276 SNDRV_CHMAP_RRC, /* back right of center */ 277 0 /* terminator */ 278 }; 279 struct snd_pcm_chmap_elem *chmap; 280 const unsigned int *maps; 281 int c; 282 283 if (channels > ARRAY_SIZE(chmap->map)) 284 return NULL; 285 286 chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); 287 if (!chmap) 288 return NULL; 289 290 maps = protocol == UAC_VERSION_2 ? uac2_maps : uac1_maps; 291 chmap->channels = channels; 292 c = 0; 293 294 if (bits) { 295 for (; bits && *maps; maps++, bits >>= 1) 296 if (bits & 1) 297 chmap->map[c++] = *maps; 298 } else { 299 /* If we're missing wChannelConfig, then guess something 300 to make sure the channel map is not skipped entirely */ 301 if (channels == 1) 302 chmap->map[c++] = SNDRV_CHMAP_MONO; 303 else 304 for (; c < channels && *maps; maps++) 305 chmap->map[c++] = *maps; 306 } 307 308 for (; c < channels; c++) 309 chmap->map[c] = SNDRV_CHMAP_UNKNOWN; 310 311 return chmap; 312 } 313 314 /* 315 * add this endpoint to the chip instance. 316 * if a stream with the same endpoint already exists, append to it. 317 * if not, create a new pcm stream. note, fp is added to the substream 318 * fmt_list and will be freed on the chip instance release. do not free 319 * fp or do remove it from the substream fmt_list to avoid double-free. 320 */ 321 int snd_usb_add_audio_stream(struct snd_usb_audio *chip, 322 int stream, 323 struct audioformat *fp) 324 { 325 struct snd_usb_stream *as; 326 struct snd_usb_substream *subs; 327 struct snd_pcm *pcm; 328 int err; 329 330 list_for_each_entry(as, &chip->pcm_list, list) { 331 if (as->fmt_type != fp->fmt_type) 332 continue; 333 subs = &as->substream[stream]; 334 if (subs->ep_num == fp->endpoint) { 335 list_add_tail(&fp->list, &subs->fmt_list); 336 subs->num_formats++; 337 subs->formats |= fp->formats; 338 return 0; 339 } 340 } 341 /* look for an empty stream */ 342 list_for_each_entry(as, &chip->pcm_list, list) { 343 if (as->fmt_type != fp->fmt_type) 344 continue; 345 subs = &as->substream[stream]; 346 if (subs->ep_num) 347 continue; 348 err = snd_pcm_new_stream(as->pcm, stream, 1); 349 if (err < 0) 350 return err; 351 snd_usb_init_substream(as, stream, fp); 352 return add_chmap(as->pcm, stream, subs); 353 } 354 355 /* create a new pcm */ 356 as = kzalloc(sizeof(*as), GFP_KERNEL); 357 if (!as) 358 return -ENOMEM; 359 as->pcm_index = chip->pcm_devs; 360 as->chip = chip; 361 as->fmt_type = fp->fmt_type; 362 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs, 363 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0, 364 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1, 365 &pcm); 366 if (err < 0) { 367 kfree(as); 368 return err; 369 } 370 as->pcm = pcm; 371 pcm->private_data = as; 372 pcm->private_free = snd_usb_audio_pcm_free; 373 pcm->info_flags = 0; 374 if (chip->pcm_devs > 0) 375 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs); 376 else 377 strcpy(pcm->name, "USB Audio"); 378 379 snd_usb_init_substream(as, stream, fp); 380 381 /* 382 * Keep using head insertion for M-Audio Audiophile USB (tm) which has a 383 * fix to swap capture stream order in conf/cards/USB-audio.conf 384 */ 385 if (chip->usb_id == USB_ID(0x0763, 0x2003)) 386 list_add(&as->list, &chip->pcm_list); 387 else 388 list_add_tail(&as->list, &chip->pcm_list); 389 390 chip->pcm_devs++; 391 392 snd_usb_proc_pcm_format_add(as); 393 394 return add_chmap(pcm, stream, &as->substream[stream]); 395 } 396 397 static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip, 398 struct usb_host_interface *alts, 399 int protocol, int iface_no) 400 { 401 /* parsed with a v1 header here. that's ok as we only look at the 402 * header first which is the same for both versions */ 403 struct uac_iso_endpoint_descriptor *csep; 404 struct usb_interface_descriptor *altsd = get_iface_desc(alts); 405 int attributes = 0; 406 407 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT); 408 409 /* Creamware Noah has this descriptor after the 2nd endpoint */ 410 if (!csep && altsd->bNumEndpoints >= 2) 411 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT); 412 413 /* 414 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra 415 * bytes after the first endpoint, go search the entire interface. 416 * Some devices have it directly *before* the standard endpoint. 417 */ 418 if (!csep) 419 csep = snd_usb_find_desc(alts->extra, alts->extralen, NULL, USB_DT_CS_ENDPOINT); 420 421 if (!csep || csep->bLength < 7 || 422 csep->bDescriptorSubtype != UAC_EP_GENERAL) { 423 usb_audio_warn(chip, 424 "%u:%d : no or invalid class specific endpoint descriptor\n", 425 iface_no, altsd->bAlternateSetting); 426 return 0; 427 } 428 429 if (protocol == UAC_VERSION_1) { 430 attributes = csep->bmAttributes; 431 } else { 432 struct uac2_iso_endpoint_descriptor *csep2 = 433 (struct uac2_iso_endpoint_descriptor *) csep; 434 435 attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX; 436 437 /* emulate the endpoint attributes of a v1 device */ 438 if (csep2->bmControls & UAC2_CONTROL_PITCH) 439 attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; 440 } 441 442 return attributes; 443 } 444 445 /* find an input terminal descriptor (either UAC1 or UAC2) with the given 446 * terminal id 447 */ 448 static void * 449 snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface, 450 int terminal_id) 451 { 452 struct uac2_input_terminal_descriptor *term = NULL; 453 454 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 455 ctrl_iface->extralen, 456 term, UAC_INPUT_TERMINAL))) { 457 if (term->bTerminalID == terminal_id) 458 return term; 459 } 460 461 return NULL; 462 } 463 464 static struct uac2_output_terminal_descriptor * 465 snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface, 466 int terminal_id) 467 { 468 struct uac2_output_terminal_descriptor *term = NULL; 469 470 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 471 ctrl_iface->extralen, 472 term, UAC_OUTPUT_TERMINAL))) { 473 if (term->bTerminalID == terminal_id) 474 return term; 475 } 476 477 return NULL; 478 } 479 480 int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no) 481 { 482 struct usb_device *dev; 483 struct usb_interface *iface; 484 struct usb_host_interface *alts; 485 struct usb_interface_descriptor *altsd; 486 int i, altno, err, stream; 487 unsigned int format = 0, num_channels = 0; 488 struct audioformat *fp = NULL; 489 int num, protocol, clock = 0; 490 struct uac_format_type_i_continuous_descriptor *fmt; 491 unsigned int chconfig; 492 493 dev = chip->dev; 494 495 /* parse the interface's altsettings */ 496 iface = usb_ifnum_to_if(dev, iface_no); 497 498 num = iface->num_altsetting; 499 500 /* 501 * Dallas DS4201 workaround: It presents 5 altsettings, but the last 502 * one misses syncpipe, and does not produce any sound. 503 */ 504 if (chip->usb_id == USB_ID(0x04fa, 0x4201)) 505 num = 4; 506 507 for (i = 0; i < num; i++) { 508 alts = &iface->altsetting[i]; 509 altsd = get_iface_desc(alts); 510 protocol = altsd->bInterfaceProtocol; 511 /* skip invalid one */ 512 if (((altsd->bInterfaceClass != USB_CLASS_AUDIO || 513 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING && 514 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC)) && 515 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 516 altsd->bNumEndpoints < 1 || 517 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0) 518 continue; 519 /* must be isochronous */ 520 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 521 USB_ENDPOINT_XFER_ISOC) 522 continue; 523 /* check direction */ 524 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ? 525 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 526 altno = altsd->bAlternateSetting; 527 528 if (snd_usb_apply_interface_quirk(chip, iface_no, altno)) 529 continue; 530 531 /* 532 * Roland audio streaming interfaces are marked with protocols 533 * 0/1/2, but are UAC 1 compatible. 534 */ 535 if (USB_ID_VENDOR(chip->usb_id) == 0x0582 && 536 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC && 537 protocol <= 2) 538 protocol = UAC_VERSION_1; 539 540 chconfig = 0; 541 /* get audio formats */ 542 switch (protocol) { 543 default: 544 dev_dbg(&dev->dev, "%u:%d: unknown interface protocol %#02x, assuming v1\n", 545 iface_no, altno, protocol); 546 protocol = UAC_VERSION_1; 547 /* fall through */ 548 549 case UAC_VERSION_1: { 550 struct uac1_as_header_descriptor *as = 551 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); 552 struct uac_input_terminal_descriptor *iterm; 553 554 if (!as) { 555 dev_err(&dev->dev, 556 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 557 iface_no, altno); 558 continue; 559 } 560 561 if (as->bLength < sizeof(*as)) { 562 dev_err(&dev->dev, 563 "%u:%d : invalid UAC_AS_GENERAL desc\n", 564 iface_no, altno); 565 continue; 566 } 567 568 format = le16_to_cpu(as->wFormatTag); /* remember the format value */ 569 570 iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 571 as->bTerminalLink); 572 if (iterm) { 573 num_channels = iterm->bNrChannels; 574 chconfig = le16_to_cpu(iterm->wChannelConfig); 575 } 576 577 break; 578 } 579 580 case UAC_VERSION_2: { 581 struct uac2_input_terminal_descriptor *input_term; 582 struct uac2_output_terminal_descriptor *output_term; 583 struct uac2_as_header_descriptor *as = 584 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); 585 586 if (!as) { 587 dev_err(&dev->dev, 588 "%u:%d : UAC_AS_GENERAL descriptor not found\n", 589 iface_no, altno); 590 continue; 591 } 592 593 if (as->bLength < sizeof(*as)) { 594 dev_err(&dev->dev, 595 "%u:%d : invalid UAC_AS_GENERAL desc\n", 596 iface_no, altno); 597 continue; 598 } 599 600 num_channels = as->bNrChannels; 601 format = le32_to_cpu(as->bmFormats); 602 chconfig = le32_to_cpu(as->bmChannelConfig); 603 604 /* lookup the terminal associated to this interface 605 * to extract the clock */ 606 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 607 as->bTerminalLink); 608 if (input_term) { 609 clock = input_term->bCSourceID; 610 if (!chconfig && (num_channels == input_term->bNrChannels)) 611 chconfig = le32_to_cpu(input_term->bmChannelConfig); 612 break; 613 } 614 615 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, 616 as->bTerminalLink); 617 if (output_term) { 618 clock = output_term->bCSourceID; 619 break; 620 } 621 622 dev_err(&dev->dev, 623 "%u:%d : bogus bTerminalLink %d\n", 624 iface_no, altno, as->bTerminalLink); 625 continue; 626 } 627 } 628 629 /* get format type */ 630 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE); 631 if (!fmt) { 632 dev_err(&dev->dev, 633 "%u:%d : no UAC_FORMAT_TYPE desc\n", 634 iface_no, altno); 635 continue; 636 } 637 if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) || 638 ((protocol == UAC_VERSION_2) && (fmt->bLength < 6))) { 639 dev_err(&dev->dev, 640 "%u:%d : invalid UAC_FORMAT_TYPE desc\n", 641 iface_no, altno); 642 continue; 643 } 644 645 /* 646 * Blue Microphones workaround: The last altsetting is identical 647 * with the previous one, except for a larger packet size, but 648 * is actually a mislabeled two-channel setting; ignore it. 649 */ 650 if (fmt->bNrChannels == 1 && 651 fmt->bSubframeSize == 2 && 652 altno == 2 && num == 3 && 653 fp && fp->altsetting == 1 && fp->channels == 1 && 654 fp->formats == SNDRV_PCM_FMTBIT_S16_LE && 655 protocol == UAC_VERSION_1 && 656 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 657 fp->maxpacksize * 2) 658 continue; 659 660 fp = kzalloc(sizeof(*fp), GFP_KERNEL); 661 if (!fp) 662 return -ENOMEM; 663 664 fp->iface = iface_no; 665 fp->altsetting = altno; 666 fp->altset_idx = i; 667 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 668 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 669 fp->datainterval = snd_usb_parse_datainterval(chip, alts); 670 fp->protocol = protocol; 671 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 672 fp->channels = num_channels; 673 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH) 674 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1) 675 * (fp->maxpacksize & 0x7ff); 676 fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no); 677 fp->clock = clock; 678 INIT_LIST_HEAD(&fp->list); 679 680 /* some quirks for attributes here */ 681 682 switch (chip->usb_id) { 683 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */ 684 /* Optoplay sets the sample rate attribute although 685 * it seems not supporting it in fact. 686 */ 687 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE; 688 break; 689 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */ 690 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ 691 /* doesn't set the sample rate attribute, but supports it */ 692 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE; 693 break; 694 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */ 695 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */ 696 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */ 697 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is 698 an older model 77d:223) */ 699 /* 700 * plantronics headset and Griffin iMic have set adaptive-in 701 * although it's really not... 702 */ 703 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE; 704 if (stream == SNDRV_PCM_STREAM_PLAYBACK) 705 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE; 706 else 707 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC; 708 break; 709 } 710 711 /* ok, let's parse further... */ 712 if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream) < 0) { 713 kfree(fp->rate_table); 714 kfree(fp); 715 fp = NULL; 716 continue; 717 } 718 719 /* Create chmap */ 720 if (fp->channels != num_channels) 721 chconfig = 0; 722 fp->chmap = convert_chmap(fp->channels, chconfig, protocol); 723 724 dev_dbg(&dev->dev, "%u:%d: add audio endpoint %#x\n", iface_no, altno, fp->endpoint); 725 err = snd_usb_add_audio_stream(chip, stream, fp); 726 if (err < 0) { 727 list_del(&fp->list); /* unlink for avoiding double-free */ 728 kfree(fp->rate_table); 729 kfree(fp->chmap); 730 kfree(fp); 731 return err; 732 } 733 /* try to set the interface... */ 734 usb_set_interface(chip->dev, iface_no, altno); 735 snd_usb_init_pitch(chip, iface_no, alts, fp); 736 snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max); 737 } 738 return 0; 739 } 740 741