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->speed = snd_usb_get_speed(subs->dev); 96 subs->pkt_offset_adj = 0; 97 98 snd_usb_set_pcm_ops(as->pcm, stream); 99 100 list_add_tail(&fp->list, &subs->fmt_list); 101 subs->formats |= fp->formats; 102 subs->num_formats++; 103 subs->fmt_type = fp->fmt_type; 104 subs->ep_num = fp->endpoint; 105 if (fp->channels > subs->channels_max) 106 subs->channels_max = fp->channels; 107 } 108 109 /* kctl callbacks for usb-audio channel maps */ 110 static int usb_chmap_ctl_info(struct snd_kcontrol *kcontrol, 111 struct snd_ctl_elem_info *uinfo) 112 { 113 struct snd_pcm_chmap *info = snd_kcontrol_chip(kcontrol); 114 struct snd_usb_substream *subs = info->private_data; 115 116 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 117 uinfo->count = subs->channels_max; 118 uinfo->value.integer.min = 0; 119 uinfo->value.integer.max = SNDRV_CHMAP_LAST; 120 return 0; 121 } 122 123 /* check whether a duplicated entry exists in the audiofmt list */ 124 static bool have_dup_chmap(struct snd_usb_substream *subs, 125 struct audioformat *fp) 126 { 127 struct list_head *p; 128 129 for (p = fp->list.prev; p != &subs->fmt_list; p = p->prev) { 130 struct audioformat *prev; 131 prev = list_entry(p, struct audioformat, 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_BLC, /* bottom left center */ 277 SNDRV_CHMAP_BRC, /* bottom right center */ 278 0 /* terminator */ 279 }; 280 struct snd_pcm_chmap_elem *chmap; 281 const unsigned int *maps; 282 int c; 283 284 if (!bits) 285 return NULL; 286 if (channels > ARRAY_SIZE(chmap->map)) 287 return NULL; 288 289 chmap = kzalloc(sizeof(*chmap), GFP_KERNEL); 290 if (!chmap) 291 return NULL; 292 293 maps = protocol == UAC_VERSION_2 ? uac2_maps : uac1_maps; 294 chmap->channels = channels; 295 c = 0; 296 for (; bits && *maps; maps++, bits >>= 1) { 297 if (bits & 1) 298 chmap->map[c++] = *maps; 299 } 300 301 for (; c < channels; c++) 302 chmap->map[c] = SNDRV_CHMAP_UNKNOWN; 303 304 return chmap; 305 } 306 307 /* 308 * add this endpoint to the chip instance. 309 * if a stream with the same endpoint already exists, append to it. 310 * if not, create a new pcm stream. 311 */ 312 int snd_usb_add_audio_stream(struct snd_usb_audio *chip, 313 int stream, 314 struct audioformat *fp) 315 { 316 struct snd_usb_stream *as; 317 struct snd_usb_substream *subs; 318 struct snd_pcm *pcm; 319 int err; 320 321 list_for_each_entry(as, &chip->pcm_list, list) { 322 if (as->fmt_type != fp->fmt_type) 323 continue; 324 subs = &as->substream[stream]; 325 if (subs->ep_num == fp->endpoint) { 326 list_add_tail(&fp->list, &subs->fmt_list); 327 subs->num_formats++; 328 subs->formats |= fp->formats; 329 return 0; 330 } 331 } 332 /* look for an empty stream */ 333 list_for_each_entry(as, &chip->pcm_list, list) { 334 if (as->fmt_type != fp->fmt_type) 335 continue; 336 subs = &as->substream[stream]; 337 if (subs->ep_num) 338 continue; 339 err = snd_pcm_new_stream(as->pcm, stream, 1); 340 if (err < 0) 341 return err; 342 snd_usb_init_substream(as, stream, fp); 343 return add_chmap(as->pcm, stream, subs); 344 } 345 346 /* create a new pcm */ 347 as = kzalloc(sizeof(*as), GFP_KERNEL); 348 if (!as) 349 return -ENOMEM; 350 as->pcm_index = chip->pcm_devs; 351 as->chip = chip; 352 as->fmt_type = fp->fmt_type; 353 err = snd_pcm_new(chip->card, "USB Audio", chip->pcm_devs, 354 stream == SNDRV_PCM_STREAM_PLAYBACK ? 1 : 0, 355 stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1, 356 &pcm); 357 if (err < 0) { 358 kfree(as); 359 return err; 360 } 361 as->pcm = pcm; 362 pcm->private_data = as; 363 pcm->private_free = snd_usb_audio_pcm_free; 364 pcm->info_flags = 0; 365 if (chip->pcm_devs > 0) 366 sprintf(pcm->name, "USB Audio #%d", chip->pcm_devs); 367 else 368 strcpy(pcm->name, "USB Audio"); 369 370 snd_usb_init_substream(as, stream, fp); 371 372 list_add(&as->list, &chip->pcm_list); 373 chip->pcm_devs++; 374 375 snd_usb_proc_pcm_format_add(as); 376 377 return add_chmap(pcm, stream, &as->substream[stream]); 378 } 379 380 static int parse_uac_endpoint_attributes(struct snd_usb_audio *chip, 381 struct usb_host_interface *alts, 382 int protocol, int iface_no) 383 { 384 /* parsed with a v1 header here. that's ok as we only look at the 385 * header first which is the same for both versions */ 386 struct uac_iso_endpoint_descriptor *csep; 387 struct usb_interface_descriptor *altsd = get_iface_desc(alts); 388 int attributes = 0; 389 390 csep = snd_usb_find_desc(alts->endpoint[0].extra, alts->endpoint[0].extralen, NULL, USB_DT_CS_ENDPOINT); 391 392 /* Creamware Noah has this descriptor after the 2nd endpoint */ 393 if (!csep && altsd->bNumEndpoints >= 2) 394 csep = snd_usb_find_desc(alts->endpoint[1].extra, alts->endpoint[1].extralen, NULL, USB_DT_CS_ENDPOINT); 395 396 /* 397 * If we can't locate the USB_DT_CS_ENDPOINT descriptor in the extra 398 * bytes after the first endpoint, go search the entire interface. 399 * Some devices have it directly *before* the standard endpoint. 400 */ 401 if (!csep) 402 csep = snd_usb_find_desc(alts->extra, alts->extralen, NULL, USB_DT_CS_ENDPOINT); 403 404 if (!csep || csep->bLength < 7 || 405 csep->bDescriptorSubtype != UAC_EP_GENERAL) { 406 snd_printk(KERN_WARNING "%d:%u:%d : no or invalid" 407 " class specific endpoint descriptor\n", 408 chip->dev->devnum, iface_no, 409 altsd->bAlternateSetting); 410 return 0; 411 } 412 413 if (protocol == UAC_VERSION_1) { 414 attributes = csep->bmAttributes; 415 } else { 416 struct uac2_iso_endpoint_descriptor *csep2 = 417 (struct uac2_iso_endpoint_descriptor *) csep; 418 419 attributes = csep->bmAttributes & UAC_EP_CS_ATTR_FILL_MAX; 420 421 /* emulate the endpoint attributes of a v1 device */ 422 if (csep2->bmControls & UAC2_CONTROL_PITCH) 423 attributes |= UAC_EP_CS_ATTR_PITCH_CONTROL; 424 } 425 426 return attributes; 427 } 428 429 /* find an input terminal descriptor (either UAC1 or UAC2) with the given 430 * terminal id 431 */ 432 static void * 433 snd_usb_find_input_terminal_descriptor(struct usb_host_interface *ctrl_iface, 434 int terminal_id) 435 { 436 struct uac2_input_terminal_descriptor *term = NULL; 437 438 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 439 ctrl_iface->extralen, 440 term, UAC_INPUT_TERMINAL))) { 441 if (term->bTerminalID == terminal_id) 442 return term; 443 } 444 445 return NULL; 446 } 447 448 static struct uac2_output_terminal_descriptor * 449 snd_usb_find_output_terminal_descriptor(struct usb_host_interface *ctrl_iface, 450 int terminal_id) 451 { 452 struct uac2_output_terminal_descriptor *term = NULL; 453 454 while ((term = snd_usb_find_csint_desc(ctrl_iface->extra, 455 ctrl_iface->extralen, 456 term, UAC_OUTPUT_TERMINAL))) { 457 if (term->bTerminalID == terminal_id) 458 return term; 459 } 460 461 return NULL; 462 } 463 464 int snd_usb_parse_audio_interface(struct snd_usb_audio *chip, int iface_no) 465 { 466 struct usb_device *dev; 467 struct usb_interface *iface; 468 struct usb_host_interface *alts; 469 struct usb_interface_descriptor *altsd; 470 int i, altno, err, stream; 471 unsigned int format = 0, num_channels = 0; 472 struct audioformat *fp = NULL; 473 int num, protocol, clock = 0; 474 struct uac_format_type_i_continuous_descriptor *fmt; 475 unsigned int chconfig; 476 477 dev = chip->dev; 478 479 /* parse the interface's altsettings */ 480 iface = usb_ifnum_to_if(dev, iface_no); 481 482 num = iface->num_altsetting; 483 484 /* 485 * Dallas DS4201 workaround: It presents 5 altsettings, but the last 486 * one misses syncpipe, and does not produce any sound. 487 */ 488 if (chip->usb_id == USB_ID(0x04fa, 0x4201)) 489 num = 4; 490 491 for (i = 0; i < num; i++) { 492 alts = &iface->altsetting[i]; 493 altsd = get_iface_desc(alts); 494 protocol = altsd->bInterfaceProtocol; 495 /* skip invalid one */ 496 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO && 497 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 498 (altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING && 499 altsd->bInterfaceSubClass != USB_SUBCLASS_VENDOR_SPEC) || 500 altsd->bNumEndpoints < 1 || 501 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 0) 502 continue; 503 /* must be isochronous */ 504 if ((get_endpoint(alts, 0)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 505 USB_ENDPOINT_XFER_ISOC) 506 continue; 507 /* check direction */ 508 stream = (get_endpoint(alts, 0)->bEndpointAddress & USB_DIR_IN) ? 509 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK; 510 altno = altsd->bAlternateSetting; 511 512 if (snd_usb_apply_interface_quirk(chip, iface_no, altno)) 513 continue; 514 515 chconfig = 0; 516 /* get audio formats */ 517 switch (protocol) { 518 default: 519 snd_printdd(KERN_WARNING "%d:%u:%d: unknown interface protocol %#02x, assuming v1\n", 520 dev->devnum, iface_no, altno, protocol); 521 protocol = UAC_VERSION_1; 522 /* fall through */ 523 524 case UAC_VERSION_1: { 525 struct uac1_as_header_descriptor *as = 526 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); 527 struct uac_input_terminal_descriptor *iterm; 528 529 if (!as) { 530 snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n", 531 dev->devnum, iface_no, altno); 532 continue; 533 } 534 535 if (as->bLength < sizeof(*as)) { 536 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n", 537 dev->devnum, iface_no, altno); 538 continue; 539 } 540 541 format = le16_to_cpu(as->wFormatTag); /* remember the format value */ 542 543 iterm = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 544 as->bTerminalLink); 545 if (iterm) { 546 num_channels = iterm->bNrChannels; 547 chconfig = le16_to_cpu(iterm->wChannelConfig); 548 } 549 550 break; 551 } 552 553 case UAC_VERSION_2: { 554 struct uac2_input_terminal_descriptor *input_term; 555 struct uac2_output_terminal_descriptor *output_term; 556 struct uac2_as_header_descriptor *as = 557 snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); 558 559 if (!as) { 560 snd_printk(KERN_ERR "%d:%u:%d : UAC_AS_GENERAL descriptor not found\n", 561 dev->devnum, iface_no, altno); 562 continue; 563 } 564 565 if (as->bLength < sizeof(*as)) { 566 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_AS_GENERAL desc\n", 567 dev->devnum, iface_no, altno); 568 continue; 569 } 570 571 num_channels = as->bNrChannels; 572 format = le32_to_cpu(as->bmFormats); 573 574 /* lookup the terminal associated to this interface 575 * to extract the clock */ 576 input_term = snd_usb_find_input_terminal_descriptor(chip->ctrl_intf, 577 as->bTerminalLink); 578 if (input_term) { 579 clock = input_term->bCSourceID; 580 chconfig = le32_to_cpu(input_term->bmChannelConfig); 581 break; 582 } 583 584 output_term = snd_usb_find_output_terminal_descriptor(chip->ctrl_intf, 585 as->bTerminalLink); 586 if (output_term) { 587 clock = output_term->bCSourceID; 588 break; 589 } 590 591 snd_printk(KERN_ERR "%d:%u:%d : bogus bTerminalLink %d\n", 592 dev->devnum, iface_no, altno, as->bTerminalLink); 593 continue; 594 } 595 } 596 597 /* get format type */ 598 fmt = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_FORMAT_TYPE); 599 if (!fmt) { 600 snd_printk(KERN_ERR "%d:%u:%d : no UAC_FORMAT_TYPE desc\n", 601 dev->devnum, iface_no, altno); 602 continue; 603 } 604 if (((protocol == UAC_VERSION_1) && (fmt->bLength < 8)) || 605 ((protocol == UAC_VERSION_2) && (fmt->bLength < 6))) { 606 snd_printk(KERN_ERR "%d:%u:%d : invalid UAC_FORMAT_TYPE desc\n", 607 dev->devnum, iface_no, altno); 608 continue; 609 } 610 611 /* 612 * Blue Microphones workaround: The last altsetting is identical 613 * with the previous one, except for a larger packet size, but 614 * is actually a mislabeled two-channel setting; ignore it. 615 */ 616 if (fmt->bNrChannels == 1 && 617 fmt->bSubframeSize == 2 && 618 altno == 2 && num == 3 && 619 fp && fp->altsetting == 1 && fp->channels == 1 && 620 fp->formats == SNDRV_PCM_FMTBIT_S16_LE && 621 protocol == UAC_VERSION_1 && 622 le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize) == 623 fp->maxpacksize * 2) 624 continue; 625 626 fp = kzalloc(sizeof(*fp), GFP_KERNEL); 627 if (! fp) { 628 snd_printk(KERN_ERR "cannot malloc\n"); 629 return -ENOMEM; 630 } 631 632 fp->iface = iface_no; 633 fp->altsetting = altno; 634 fp->altset_idx = i; 635 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress; 636 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes; 637 fp->datainterval = snd_usb_parse_datainterval(chip, alts); 638 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize); 639 fp->channels = num_channels; 640 if (snd_usb_get_speed(dev) == USB_SPEED_HIGH) 641 fp->maxpacksize = (((fp->maxpacksize >> 11) & 3) + 1) 642 * (fp->maxpacksize & 0x7ff); 643 fp->attributes = parse_uac_endpoint_attributes(chip, alts, protocol, iface_no); 644 fp->clock = clock; 645 fp->chmap = convert_chmap(num_channels, chconfig, protocol); 646 647 /* some quirks for attributes here */ 648 649 switch (chip->usb_id) { 650 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */ 651 /* Optoplay sets the sample rate attribute although 652 * it seems not supporting it in fact. 653 */ 654 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE; 655 break; 656 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */ 657 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ 658 /* doesn't set the sample rate attribute, but supports it */ 659 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE; 660 break; 661 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */ 662 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */ 663 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */ 664 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is 665 an older model 77d:223) */ 666 /* 667 * plantronics headset and Griffin iMic have set adaptive-in 668 * although it's really not... 669 */ 670 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE; 671 if (stream == SNDRV_PCM_STREAM_PLAYBACK) 672 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE; 673 else 674 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC; 675 break; 676 } 677 678 /* ok, let's parse further... */ 679 if (snd_usb_parse_audio_format(chip, fp, format, fmt, stream, alts) < 0) { 680 kfree(fp->rate_table); 681 kfree(fp->chmap); 682 kfree(fp); 683 fp = NULL; 684 continue; 685 } 686 687 snd_printdd(KERN_INFO "%d:%u:%d: add audio endpoint %#x\n", dev->devnum, iface_no, altno, fp->endpoint); 688 err = snd_usb_add_audio_stream(chip, stream, fp); 689 if (err < 0) { 690 kfree(fp->rate_table); 691 kfree(fp->chmap); 692 kfree(fp); 693 return err; 694 } 695 /* try to set the interface... */ 696 usb_set_interface(chip->dev, iface_no, altno); 697 snd_usb_init_pitch(chip, iface_no, alts, fp); 698 snd_usb_init_sample_rate(chip, iface_no, alts, fp, fp->rate_max); 699 } 700 return 0; 701 } 702 703