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