• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/usb.h>
20 #include <linux/usb/audio.h>
21 #include <linux/usb/midi.h>
22 
23 #include <sound/control.h>
24 #include <sound/core.h>
25 #include <sound/info.h>
26 #include <sound/pcm.h>
27 
28 #include "usbaudio.h"
29 #include "card.h"
30 #include "mixer.h"
31 #include "mixer_quirks.h"
32 #include "midi.h"
33 #include "quirks.h"
34 #include "helper.h"
35 #include "endpoint.h"
36 #include "pcm.h"
37 #include "clock.h"
38 #include "stream.h"
39 
40 /*
41  * handle the quirks for the contained interfaces
42  */
create_composite_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk_comp)43 static int create_composite_quirk(struct snd_usb_audio *chip,
44 				  struct usb_interface *iface,
45 				  struct usb_driver *driver,
46 				  const struct snd_usb_audio_quirk *quirk_comp)
47 {
48 	int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
49 	const struct snd_usb_audio_quirk *quirk;
50 	int err;
51 
52 	for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
53 		iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
54 		if (!iface)
55 			continue;
56 		if (quirk->ifnum != probed_ifnum &&
57 		    usb_interface_claimed(iface))
58 			continue;
59 		err = snd_usb_create_quirk(chip, iface, driver, quirk);
60 		if (err < 0)
61 			return err;
62 	}
63 
64 	for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {
65 		iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);
66 		if (!iface)
67 			continue;
68 		if (quirk->ifnum != probed_ifnum &&
69 		    !usb_interface_claimed(iface))
70 			usb_driver_claim_interface(driver, iface, (void *)-1L);
71 	}
72 
73 	return 0;
74 }
75 
ignore_interface_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)76 static int ignore_interface_quirk(struct snd_usb_audio *chip,
77 				  struct usb_interface *iface,
78 				  struct usb_driver *driver,
79 				  const struct snd_usb_audio_quirk *quirk)
80 {
81 	return 0;
82 }
83 
84 
85 /*
86  * Allow alignment on audio sub-slot (channel samples) rather than
87  * on audio slots (audio frames)
88  */
create_align_transfer_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)89 static int create_align_transfer_quirk(struct snd_usb_audio *chip,
90 				       struct usb_interface *iface,
91 				       struct usb_driver *driver,
92 				       const struct snd_usb_audio_quirk *quirk)
93 {
94 	chip->txfr_quirk = 1;
95 	return 1;	/* Continue with creating streams and mixer */
96 }
97 
create_any_midi_quirk(struct snd_usb_audio * chip,struct usb_interface * intf,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)98 static int create_any_midi_quirk(struct snd_usb_audio *chip,
99 				 struct usb_interface *intf,
100 				 struct usb_driver *driver,
101 				 const struct snd_usb_audio_quirk *quirk)
102 {
103 	return snd_usbmidi_create(chip->card, intf, &chip->midi_list, quirk);
104 }
105 
106 /*
107  * create a stream for an interface with proper descriptors
108  */
create_standard_audio_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)109 static int create_standard_audio_quirk(struct snd_usb_audio *chip,
110 				       struct usb_interface *iface,
111 				       struct usb_driver *driver,
112 				       const struct snd_usb_audio_quirk *quirk)
113 {
114 	struct usb_host_interface *alts;
115 	struct usb_interface_descriptor *altsd;
116 	int err;
117 
118 	if (chip->usb_id == USB_ID(0x1686, 0x00dd)) /* Zoom R16/24 */
119 		chip->tx_length_quirk = 1;
120 
121 	alts = &iface->altsetting[0];
122 	altsd = get_iface_desc(alts);
123 	err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);
124 	if (err < 0) {
125 		usb_audio_err(chip, "cannot setup if %d: error %d\n",
126 			   altsd->bInterfaceNumber, err);
127 		return err;
128 	}
129 	/* reset the current interface */
130 	usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);
131 	return 0;
132 }
133 
134 /*
135  * create a stream for an endpoint/altsetting without proper descriptors
136  */
create_fixed_stream_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)137 static int create_fixed_stream_quirk(struct snd_usb_audio *chip,
138 				     struct usb_interface *iface,
139 				     struct usb_driver *driver,
140 				     const struct snd_usb_audio_quirk *quirk)
141 {
142 	struct audioformat *fp;
143 	struct usb_host_interface *alts;
144 	struct usb_interface_descriptor *altsd;
145 	int stream, err;
146 	unsigned *rate_table = NULL;
147 
148 	fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);
149 	if (!fp) {
150 		usb_audio_err(chip, "cannot memdup\n");
151 		return -ENOMEM;
152 	}
153 	INIT_LIST_HEAD(&fp->list);
154 	if (fp->nr_rates > MAX_NR_RATES) {
155 		kfree(fp);
156 		return -EINVAL;
157 	}
158 	if (fp->nr_rates > 0) {
159 		rate_table = kmemdup(fp->rate_table,
160 				     sizeof(int) * fp->nr_rates, GFP_KERNEL);
161 		if (!rate_table) {
162 			kfree(fp);
163 			return -ENOMEM;
164 		}
165 		fp->rate_table = rate_table;
166 	}
167 
168 	stream = (fp->endpoint & USB_DIR_IN)
169 		? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
170 	err = snd_usb_add_audio_stream(chip, stream, fp);
171 	if (err < 0)
172 		goto error;
173 	if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||
174 	    fp->altset_idx >= iface->num_altsetting) {
175 		err = -EINVAL;
176 		goto error;
177 	}
178 	alts = &iface->altsetting[fp->altset_idx];
179 	altsd = get_iface_desc(alts);
180 	if (altsd->bNumEndpoints < 1) {
181 		err = -EINVAL;
182 		goto error;
183 	}
184 
185 	fp->protocol = altsd->bInterfaceProtocol;
186 
187 	if (fp->datainterval == 0)
188 		fp->datainterval = snd_usb_parse_datainterval(chip, alts);
189 	if (fp->maxpacksize == 0)
190 		fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
191 	usb_set_interface(chip->dev, fp->iface, 0);
192 	snd_usb_init_pitch(chip, fp->iface, alts, fp);
193 	snd_usb_init_sample_rate(chip, fp->iface, alts, fp, fp->rate_max);
194 	return 0;
195 
196  error:
197 	list_del(&fp->list); /* unlink for avoiding double-free */
198 	kfree(fp);
199 	kfree(rate_table);
200 	return err;
201 }
202 
create_auto_pcm_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver)203 static int create_auto_pcm_quirk(struct snd_usb_audio *chip,
204 				 struct usb_interface *iface,
205 				 struct usb_driver *driver)
206 {
207 	struct usb_host_interface *alts;
208 	struct usb_interface_descriptor *altsd;
209 	struct usb_endpoint_descriptor *epd;
210 	struct uac1_as_header_descriptor *ashd;
211 	struct uac_format_type_i_discrete_descriptor *fmtd;
212 
213 	/*
214 	 * Most Roland/Yamaha audio streaming interfaces have more or less
215 	 * standard descriptors, but older devices might lack descriptors, and
216 	 * future ones might change, so ensure that we fail silently if the
217 	 * interface doesn't look exactly right.
218 	 */
219 
220 	/* must have a non-zero altsetting for streaming */
221 	if (iface->num_altsetting < 2)
222 		return -ENODEV;
223 	alts = &iface->altsetting[1];
224 	altsd = get_iface_desc(alts);
225 
226 	/* must have an isochronous endpoint for streaming */
227 	if (altsd->bNumEndpoints < 1)
228 		return -ENODEV;
229 	epd = get_endpoint(alts, 0);
230 	if (!usb_endpoint_xfer_isoc(epd))
231 		return -ENODEV;
232 
233 	/* must have format descriptors */
234 	ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
235 				       UAC_AS_GENERAL);
236 	fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,
237 				       UAC_FORMAT_TYPE);
238 	if (!ashd || ashd->bLength < 7 ||
239 	    !fmtd || fmtd->bLength < 8)
240 		return -ENODEV;
241 
242 	return create_standard_audio_quirk(chip, iface, driver, NULL);
243 }
244 
create_yamaha_midi_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,struct usb_host_interface * alts)245 static int create_yamaha_midi_quirk(struct snd_usb_audio *chip,
246 				    struct usb_interface *iface,
247 				    struct usb_driver *driver,
248 				    struct usb_host_interface *alts)
249 {
250 	static const struct snd_usb_audio_quirk yamaha_midi_quirk = {
251 		.type = QUIRK_MIDI_YAMAHA
252 	};
253 	struct usb_midi_in_jack_descriptor *injd;
254 	struct usb_midi_out_jack_descriptor *outjd;
255 
256 	/* must have some valid jack descriptors */
257 	injd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
258 				       NULL, USB_MS_MIDI_IN_JACK);
259 	outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen,
260 					NULL, USB_MS_MIDI_OUT_JACK);
261 	if (!injd && !outjd)
262 		return -ENODEV;
263 	if (injd && (injd->bLength < 5 ||
264 		     (injd->bJackType != USB_MS_EMBEDDED &&
265 		      injd->bJackType != USB_MS_EXTERNAL)))
266 		return -ENODEV;
267 	if (outjd && (outjd->bLength < 6 ||
268 		      (outjd->bJackType != USB_MS_EMBEDDED &&
269 		       outjd->bJackType != USB_MS_EXTERNAL)))
270 		return -ENODEV;
271 	return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk);
272 }
273 
create_roland_midi_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,struct usb_host_interface * alts)274 static int create_roland_midi_quirk(struct snd_usb_audio *chip,
275 				    struct usb_interface *iface,
276 				    struct usb_driver *driver,
277 				    struct usb_host_interface *alts)
278 {
279 	static const struct snd_usb_audio_quirk roland_midi_quirk = {
280 		.type = QUIRK_MIDI_ROLAND
281 	};
282 	u8 *roland_desc = NULL;
283 
284 	/* might have a vendor-specific descriptor <06 24 F1 02 ...> */
285 	for (;;) {
286 		roland_desc = snd_usb_find_csint_desc(alts->extra,
287 						      alts->extralen,
288 						      roland_desc, 0xf1);
289 		if (!roland_desc)
290 			return -ENODEV;
291 		if (roland_desc[0] < 6 || roland_desc[3] != 2)
292 			continue;
293 		return create_any_midi_quirk(chip, iface, driver,
294 					     &roland_midi_quirk);
295 	}
296 }
297 
create_std_midi_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,struct usb_host_interface * alts)298 static int create_std_midi_quirk(struct snd_usb_audio *chip,
299 				 struct usb_interface *iface,
300 				 struct usb_driver *driver,
301 				 struct usb_host_interface *alts)
302 {
303 	struct usb_ms_header_descriptor *mshd;
304 	struct usb_ms_endpoint_descriptor *msepd;
305 
306 	/* must have the MIDIStreaming interface header descriptor*/
307 	mshd = (struct usb_ms_header_descriptor *)alts->extra;
308 	if (alts->extralen < 7 ||
309 	    mshd->bLength < 7 ||
310 	    mshd->bDescriptorType != USB_DT_CS_INTERFACE ||
311 	    mshd->bDescriptorSubtype != USB_MS_HEADER)
312 		return -ENODEV;
313 	/* must have the MIDIStreaming endpoint descriptor*/
314 	msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra;
315 	if (alts->endpoint[0].extralen < 4 ||
316 	    msepd->bLength < 4 ||
317 	    msepd->bDescriptorType != USB_DT_CS_ENDPOINT ||
318 	    msepd->bDescriptorSubtype != UAC_MS_GENERAL ||
319 	    msepd->bNumEmbMIDIJack < 1 ||
320 	    msepd->bNumEmbMIDIJack > 16)
321 		return -ENODEV;
322 
323 	return create_any_midi_quirk(chip, iface, driver, NULL);
324 }
325 
create_auto_midi_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver)326 static int create_auto_midi_quirk(struct snd_usb_audio *chip,
327 				  struct usb_interface *iface,
328 				  struct usb_driver *driver)
329 {
330 	struct usb_host_interface *alts;
331 	struct usb_interface_descriptor *altsd;
332 	struct usb_endpoint_descriptor *epd;
333 	int err;
334 
335 	alts = &iface->altsetting[0];
336 	altsd = get_iface_desc(alts);
337 
338 	/* must have at least one bulk/interrupt endpoint for streaming */
339 	if (altsd->bNumEndpoints < 1)
340 		return -ENODEV;
341 	epd = get_endpoint(alts, 0);
342 	if (!usb_endpoint_xfer_bulk(epd) &&
343 	    !usb_endpoint_xfer_int(epd))
344 		return -ENODEV;
345 
346 	switch (USB_ID_VENDOR(chip->usb_id)) {
347 	case 0x0499: /* Yamaha */
348 		err = create_yamaha_midi_quirk(chip, iface, driver, alts);
349 		if (err != -ENODEV)
350 			return err;
351 		break;
352 	case 0x0582: /* Roland */
353 		err = create_roland_midi_quirk(chip, iface, driver, alts);
354 		if (err != -ENODEV)
355 			return err;
356 		break;
357 	}
358 
359 	return create_std_midi_quirk(chip, iface, driver, alts);
360 }
361 
create_autodetect_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver)362 static int create_autodetect_quirk(struct snd_usb_audio *chip,
363 				   struct usb_interface *iface,
364 				   struct usb_driver *driver)
365 {
366 	int err;
367 
368 	err = create_auto_pcm_quirk(chip, iface, driver);
369 	if (err == -ENODEV)
370 		err = create_auto_midi_quirk(chip, iface, driver);
371 	return err;
372 }
373 
create_autodetect_quirks(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)374 static int create_autodetect_quirks(struct snd_usb_audio *chip,
375 				    struct usb_interface *iface,
376 				    struct usb_driver *driver,
377 				    const struct snd_usb_audio_quirk *quirk)
378 {
379 	int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;
380 	int ifcount, ifnum, err;
381 
382 	err = create_autodetect_quirk(chip, iface, driver);
383 	if (err < 0)
384 		return err;
385 
386 	/*
387 	 * ALSA PCM playback/capture devices cannot be registered in two steps,
388 	 * so we have to claim the other corresponding interface here.
389 	 */
390 	ifcount = chip->dev->actconfig->desc.bNumInterfaces;
391 	for (ifnum = 0; ifnum < ifcount; ifnum++) {
392 		if (ifnum == probed_ifnum || quirk->ifnum >= 0)
393 			continue;
394 		iface = usb_ifnum_to_if(chip->dev, ifnum);
395 		if (!iface ||
396 		    usb_interface_claimed(iface) ||
397 		    get_iface_desc(iface->altsetting)->bInterfaceClass !=
398 							USB_CLASS_VENDOR_SPEC)
399 			continue;
400 
401 		err = create_autodetect_quirk(chip, iface, driver);
402 		if (err >= 0)
403 			usb_driver_claim_interface(driver, iface, (void *)-1L);
404 	}
405 
406 	return 0;
407 }
408 
409 /*
410  * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
411  * The only way to detect the sample rate is by looking at wMaxPacketSize.
412  */
create_uaxx_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)413 static int create_uaxx_quirk(struct snd_usb_audio *chip,
414 			     struct usb_interface *iface,
415 			     struct usb_driver *driver,
416 			     const struct snd_usb_audio_quirk *quirk)
417 {
418 	static const struct audioformat ua_format = {
419 		.formats = SNDRV_PCM_FMTBIT_S24_3LE,
420 		.channels = 2,
421 		.fmt_type = UAC_FORMAT_TYPE_I,
422 		.altsetting = 1,
423 		.altset_idx = 1,
424 		.rates = SNDRV_PCM_RATE_CONTINUOUS,
425 	};
426 	struct usb_host_interface *alts;
427 	struct usb_interface_descriptor *altsd;
428 	struct audioformat *fp;
429 	int stream, err;
430 
431 	/* both PCM and MIDI interfaces have 2 or more altsettings */
432 	if (iface->num_altsetting < 2)
433 		return -ENXIO;
434 	alts = &iface->altsetting[1];
435 	altsd = get_iface_desc(alts);
436 
437 	if (altsd->bNumEndpoints == 2) {
438 		static const struct snd_usb_midi_endpoint_info ua700_ep = {
439 			.out_cables = 0x0003,
440 			.in_cables  = 0x0003
441 		};
442 		static const struct snd_usb_audio_quirk ua700_quirk = {
443 			.type = QUIRK_MIDI_FIXED_ENDPOINT,
444 			.data = &ua700_ep
445 		};
446 		static const struct snd_usb_midi_endpoint_info uaxx_ep = {
447 			.out_cables = 0x0001,
448 			.in_cables  = 0x0001
449 		};
450 		static const struct snd_usb_audio_quirk uaxx_quirk = {
451 			.type = QUIRK_MIDI_FIXED_ENDPOINT,
452 			.data = &uaxx_ep
453 		};
454 		const struct snd_usb_audio_quirk *quirk =
455 			chip->usb_id == USB_ID(0x0582, 0x002b)
456 			? &ua700_quirk : &uaxx_quirk;
457 		return __snd_usbmidi_create(chip->card, iface,
458 					  &chip->midi_list, quirk,
459 					  chip->usb_id);
460 	}
461 
462 	if (altsd->bNumEndpoints != 1)
463 		return -ENXIO;
464 
465 	fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL);
466 	if (!fp)
467 		return -ENOMEM;
468 
469 	fp->iface = altsd->bInterfaceNumber;
470 	fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;
471 	fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;
472 	fp->datainterval = 0;
473 	fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);
474 	INIT_LIST_HEAD(&fp->list);
475 
476 	switch (fp->maxpacksize) {
477 	case 0x120:
478 		fp->rate_max = fp->rate_min = 44100;
479 		break;
480 	case 0x138:
481 	case 0x140:
482 		fp->rate_max = fp->rate_min = 48000;
483 		break;
484 	case 0x258:
485 	case 0x260:
486 		fp->rate_max = fp->rate_min = 96000;
487 		break;
488 	default:
489 		usb_audio_err(chip, "unknown sample rate\n");
490 		kfree(fp);
491 		return -ENXIO;
492 	}
493 
494 	stream = (fp->endpoint & USB_DIR_IN)
495 		? SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
496 	err = snd_usb_add_audio_stream(chip, stream, fp);
497 	if (err < 0) {
498 		list_del(&fp->list); /* unlink for avoiding double-free */
499 		kfree(fp);
500 		return err;
501 	}
502 	usb_set_interface(chip->dev, fp->iface, 0);
503 	return 0;
504 }
505 
506 /*
507  * Create a standard mixer for the specified interface.
508  */
create_standard_mixer_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)509 static int create_standard_mixer_quirk(struct snd_usb_audio *chip,
510 				       struct usb_interface *iface,
511 				       struct usb_driver *driver,
512 				       const struct snd_usb_audio_quirk *quirk)
513 {
514 	if (quirk->ifnum < 0)
515 		return 0;
516 
517 	return snd_usb_create_mixer(chip, quirk->ifnum, 0);
518 }
519 
520 /*
521  * audio-interface quirks
522  *
523  * returns zero if no standard audio/MIDI parsing is needed.
524  * returns a positive value if standard audio/midi interfaces are parsed
525  * after this.
526  * returns a negative value at error.
527  */
snd_usb_create_quirk(struct snd_usb_audio * chip,struct usb_interface * iface,struct usb_driver * driver,const struct snd_usb_audio_quirk * quirk)528 int snd_usb_create_quirk(struct snd_usb_audio *chip,
529 			 struct usb_interface *iface,
530 			 struct usb_driver *driver,
531 			 const struct snd_usb_audio_quirk *quirk)
532 {
533 	typedef int (*quirk_func_t)(struct snd_usb_audio *,
534 				    struct usb_interface *,
535 				    struct usb_driver *,
536 				    const struct snd_usb_audio_quirk *);
537 	static const quirk_func_t quirk_funcs[] = {
538 		[QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,
539 		[QUIRK_COMPOSITE] = create_composite_quirk,
540 		[QUIRK_AUTODETECT] = create_autodetect_quirks,
541 		[QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,
542 		[QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,
543 		[QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,
544 		[QUIRK_MIDI_ROLAND] = create_any_midi_quirk,
545 		[QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,
546 		[QUIRK_MIDI_NOVATION] = create_any_midi_quirk,
547 		[QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk,
548 		[QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,
549 		[QUIRK_MIDI_CME] = create_any_midi_quirk,
550 		[QUIRK_MIDI_AKAI] = create_any_midi_quirk,
551 		[QUIRK_MIDI_FTDI] = create_any_midi_quirk,
552 		[QUIRK_MIDI_CH345] = create_any_midi_quirk,
553 		[QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,
554 		[QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,
555 		[QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,
556 		[QUIRK_AUDIO_ALIGN_TRANSFER] = create_align_transfer_quirk,
557 		[QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,
558 	};
559 
560 	if (quirk->type < QUIRK_TYPE_COUNT) {
561 		return quirk_funcs[quirk->type](chip, iface, driver, quirk);
562 	} else {
563 		usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);
564 		return -ENXIO;
565 	}
566 }
567 
568 /*
569  * boot quirks
570  */
571 
572 #define EXTIGY_FIRMWARE_SIZE_OLD 794
573 #define EXTIGY_FIRMWARE_SIZE_NEW 483
574 
snd_usb_extigy_boot_quirk(struct usb_device * dev,struct usb_interface * intf)575 static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)
576 {
577 	struct usb_host_config *config = dev->actconfig;
578 	int err;
579 
580 	if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||
581 	    le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {
582 		dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");
583 		/* Send message to force it to reconnect with full interface. */
584 		err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),
585 				      0x10, 0x43, 0x0001, 0x000a, NULL, 0);
586 		if (err < 0)
587 			dev_dbg(&dev->dev, "error sending boot message: %d\n", err);
588 		err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
589 				&dev->descriptor, sizeof(dev->descriptor));
590 		config = dev->actconfig;
591 		if (err < 0)
592 			dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
593 		err = usb_reset_configuration(dev);
594 		if (err < 0)
595 			dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
596 		dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",
597 			    le16_to_cpu(get_cfg_desc(config)->wTotalLength));
598 		return -ENODEV; /* quit this anyway */
599 	}
600 	return 0;
601 }
602 
snd_usb_audigy2nx_boot_quirk(struct usb_device * dev)603 static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)
604 {
605 	u8 buf = 1;
606 
607 	snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,
608 			USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,
609 			0, 0, &buf, 1);
610 	if (buf == 0) {
611 		snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,
612 				USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,
613 				1, 2000, NULL, 0);
614 		return -ENODEV;
615 	}
616 	return 0;
617 }
618 
snd_usb_fasttrackpro_boot_quirk(struct usb_device * dev)619 static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)
620 {
621 	int err;
622 
623 	if (dev->actconfig->desc.bConfigurationValue == 1) {
624 		dev_info(&dev->dev,
625 			   "Fast Track Pro switching to config #2\n");
626 		/* This function has to be available by the usb core module.
627 		 * if it is not avialable the boot quirk has to be left out
628 		 * and the configuration has to be set by udev or hotplug
629 		 * rules
630 		 */
631 		err = usb_driver_set_configuration(dev, 2);
632 		if (err < 0)
633 			dev_dbg(&dev->dev,
634 				"error usb_driver_set_configuration: %d\n",
635 				err);
636 		/* Always return an error, so that we stop creating a device
637 		   that will just be destroyed and recreated with a new
638 		   configuration */
639 		return -ENODEV;
640 	} else
641 		dev_info(&dev->dev, "Fast Track Pro config OK\n");
642 
643 	return 0;
644 }
645 
646 /*
647  * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
648  * documented in the device's data sheet.
649  */
snd_usb_cm106_write_int_reg(struct usb_device * dev,int reg,u16 value)650 static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)
651 {
652 	u8 buf[4];
653 	buf[0] = 0x20;
654 	buf[1] = value & 0xff;
655 	buf[2] = (value >> 8) & 0xff;
656 	buf[3] = reg;
657 	return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,
658 			       USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
659 			       0, 0, &buf, 4);
660 }
661 
snd_usb_cm106_boot_quirk(struct usb_device * dev)662 static int snd_usb_cm106_boot_quirk(struct usb_device *dev)
663 {
664 	/*
665 	 * Enable line-out driver mode, set headphone source to front
666 	 * channels, enable stereo mic.
667 	 */
668 	return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);
669 }
670 
671 /*
672  * C-Media CM6206 is based on CM106 with two additional
673  * registers that are not documented in the data sheet.
674  * Values here are chosen based on sniffing USB traffic
675  * under Windows.
676  */
snd_usb_cm6206_boot_quirk(struct usb_device * dev)677 static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)
678 {
679 	int err  = 0, reg;
680 	int val[] = {0x2004, 0x3000, 0xf800, 0x143f, 0x0000, 0x3000};
681 
682 	for (reg = 0; reg < ARRAY_SIZE(val); reg++) {
683 		err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);
684 		if (err < 0)
685 			return err;
686 	}
687 
688 	return err;
689 }
690 
691 /* quirk for Plantronics GameCom 780 with CM6302 chip */
snd_usb_gamecon780_boot_quirk(struct usb_device * dev)692 static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev)
693 {
694 	/* set the initial volume and don't change; other values are either
695 	 * too loud or silent due to firmware bug (bko#65251)
696 	 */
697 	u8 buf[2] = { 0x74, 0xe3 };
698 	return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
699 			USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,
700 			UAC_FU_VOLUME << 8, 9 << 8, buf, 2);
701 }
702 
703 /*
704  * Novation Twitch DJ controller
705  * Focusrite Novation Saffire 6 USB audio card
706  */
snd_usb_novation_boot_quirk(struct usb_device * dev)707 static int snd_usb_novation_boot_quirk(struct usb_device *dev)
708 {
709 	/* preemptively set up the device because otherwise the
710 	 * raw MIDI endpoints are not active */
711 	usb_set_interface(dev, 0, 1);
712 	return 0;
713 }
714 
715 /*
716  * This call will put the synth in "USB send" mode, i.e it will send MIDI
717  * messages through USB (this is disabled at startup). The synth will
718  * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
719  * sign on its LCD. Values here are chosen based on sniffing USB traffic
720  * under Windows.
721  */
snd_usb_accessmusic_boot_quirk(struct usb_device * dev)722 static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)
723 {
724 	int err, actual_length;
725 
726 	/* "midi send" enable */
727 	static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };
728 
729 	void *buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);
730 	if (!buf)
731 		return -ENOMEM;
732 	err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,
733 			ARRAY_SIZE(seq), &actual_length, 1000);
734 	kfree(buf);
735 	if (err < 0)
736 		return err;
737 
738 	return 0;
739 }
740 
741 /*
742  * Some sound cards from Native Instruments are in fact compliant to the USB
743  * audio standard of version 2 and other approved USB standards, even though
744  * they come up as vendor-specific device when first connected.
745  *
746  * However, they can be told to come up with a new set of descriptors
747  * upon their next enumeration, and the interfaces announced by the new
748  * descriptors will then be handled by the kernel's class drivers. As the
749  * product ID will also change, no further checks are required.
750  */
751 
snd_usb_nativeinstruments_boot_quirk(struct usb_device * dev)752 static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev)
753 {
754 	int ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
755 				  0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
756 				  1, 0, NULL, 0, 1000);
757 
758 	if (ret < 0)
759 		return ret;
760 
761 	usb_reset_device(dev);
762 
763 	/* return -EAGAIN, so the creation of an audio interface for this
764 	 * temporary device is aborted. The device will reconnect with a
765 	 * new product ID */
766 	return -EAGAIN;
767 }
768 
mbox2_setup_48_24_magic(struct usb_device * dev)769 static void mbox2_setup_48_24_magic(struct usb_device *dev)
770 {
771 	u8 srate[3];
772 	u8 temp[12];
773 
774 	/* Choose 48000Hz permanently */
775 	srate[0] = 0x80;
776 	srate[1] = 0xbb;
777 	srate[2] = 0x00;
778 
779 	/* Send the magic! */
780 	snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
781 		0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003);
782 	snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
783 		0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003);
784 	snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
785 		0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003);
786 	snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),
787 		0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003);
788 	return;
789 }
790 
791 /* Digidesign Mbox 2 needs to load firmware onboard
792  * and driver must wait a few seconds for initialisation.
793  */
794 
795 #define MBOX2_FIRMWARE_SIZE    646
796 #define MBOX2_BOOT_LOADING     0x01 /* Hard coded into the device */
797 #define MBOX2_BOOT_READY       0x02 /* Hard coded into the device */
798 
snd_usb_mbox2_boot_quirk(struct usb_device * dev)799 static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)
800 {
801 	struct usb_host_config *config = dev->actconfig;
802 	int err;
803 	u8 bootresponse[0x12];
804 	int fwsize;
805 	int count;
806 
807 	fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);
808 
809 	if (fwsize != MBOX2_FIRMWARE_SIZE) {
810 		dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);
811 		return -ENODEV;
812 	}
813 
814 	dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");
815 
816 	count = 0;
817 	bootresponse[0] = MBOX2_BOOT_LOADING;
818 	while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) {
819 		msleep(500); /* 0.5 second delay */
820 		snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),
821 			/* Control magic - load onboard firmware */
822 			0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);
823 		if (bootresponse[0] == MBOX2_BOOT_READY)
824 			break;
825 		dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");
826 		count++;
827 	}
828 
829 	if (bootresponse[0] != MBOX2_BOOT_READY) {
830 		dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);
831 		return -ENODEV;
832 	}
833 
834 	dev_dbg(&dev->dev, "device initialised!\n");
835 
836 	err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,
837 		&dev->descriptor, sizeof(dev->descriptor));
838 	config = dev->actconfig;
839 	if (err < 0)
840 		dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);
841 
842 	err = usb_reset_configuration(dev);
843 	if (err < 0)
844 		dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);
845 	dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",
846 		le16_to_cpu(get_cfg_desc(config)->wTotalLength));
847 
848 	mbox2_setup_48_24_magic(dev);
849 
850 	dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");
851 
852 	return 0; /* Successful boot */
853 }
854 
855 /*
856  * Setup quirks
857  */
858 #define MAUDIO_SET		0x01 /* parse device_setup */
859 #define MAUDIO_SET_COMPATIBLE	0x80 /* use only "win-compatible" interfaces */
860 #define MAUDIO_SET_DTS		0x02 /* enable DTS Digital Output */
861 #define MAUDIO_SET_96K		0x04 /* 48-96KHz rate if set, 8-48KHz otherwise */
862 #define MAUDIO_SET_24B		0x08 /* 24bits sample if set, 16bits otherwise */
863 #define MAUDIO_SET_DI		0x10 /* enable Digital Input */
864 #define MAUDIO_SET_MASK		0x1f /* bit mask for setup value */
865 #define MAUDIO_SET_24B_48K_DI	 0x19 /* 24bits+48KHz+Digital Input */
866 #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48KHz+No Digital Input */
867 #define MAUDIO_SET_16B_48K_DI	 0x11 /* 16bits+48KHz+Digital Input */
868 #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48KHz+No Digital Input */
869 
quattro_skip_setting_quirk(struct snd_usb_audio * chip,int iface,int altno)870 static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,
871 				      int iface, int altno)
872 {
873 	/* Reset ALL ifaces to 0 altsetting.
874 	 * Call it for every possible altsetting of every interface.
875 	 */
876 	usb_set_interface(chip->dev, iface, 0);
877 	if (chip->setup & MAUDIO_SET) {
878 		if (chip->setup & MAUDIO_SET_COMPATIBLE) {
879 			if (iface != 1 && iface != 2)
880 				return 1; /* skip all interfaces but 1 and 2 */
881 		} else {
882 			unsigned int mask;
883 			if (iface == 1 || iface == 2)
884 				return 1; /* skip interfaces 1 and 2 */
885 			if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
886 				return 1; /* skip this altsetting */
887 			mask = chip->setup & MAUDIO_SET_MASK;
888 			if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
889 				return 1; /* skip this altsetting */
890 			if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
891 				return 1; /* skip this altsetting */
892 			if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4)
893 				return 1; /* skip this altsetting */
894 		}
895 	}
896 	usb_audio_dbg(chip,
897 		    "using altsetting %d for interface %d config %d\n",
898 		    altno, iface, chip->setup);
899 	return 0; /* keep this altsetting */
900 }
901 
audiophile_skip_setting_quirk(struct snd_usb_audio * chip,int iface,int altno)902 static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,
903 					 int iface,
904 					 int altno)
905 {
906 	/* Reset ALL ifaces to 0 altsetting.
907 	 * Call it for every possible altsetting of every interface.
908 	 */
909 	usb_set_interface(chip->dev, iface, 0);
910 
911 	if (chip->setup & MAUDIO_SET) {
912 		unsigned int mask;
913 		if ((chip->setup & MAUDIO_SET_DTS) && altno != 6)
914 			return 1; /* skip this altsetting */
915 		if ((chip->setup & MAUDIO_SET_96K) && altno != 1)
916 			return 1; /* skip this altsetting */
917 		mask = chip->setup & MAUDIO_SET_MASK;
918 		if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)
919 			return 1; /* skip this altsetting */
920 		if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)
921 			return 1; /* skip this altsetting */
922 		if (mask == MAUDIO_SET_16B_48K_DI && altno != 4)
923 			return 1; /* skip this altsetting */
924 		if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5)
925 			return 1; /* skip this altsetting */
926 	}
927 
928 	return 0; /* keep this altsetting */
929 }
930 
fasttrackpro_skip_setting_quirk(struct snd_usb_audio * chip,int iface,int altno)931 static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,
932 					   int iface, int altno)
933 {
934 	/* Reset ALL ifaces to 0 altsetting.
935 	 * Call it for every possible altsetting of every interface.
936 	 */
937 	usb_set_interface(chip->dev, iface, 0);
938 
939 	/* possible configuration where both inputs and only one output is
940 	 *used is not supported by the current setup
941 	 */
942 	if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) {
943 		if (chip->setup & MAUDIO_SET_96K) {
944 			if (altno != 3 && altno != 6)
945 				return 1;
946 		} else if (chip->setup & MAUDIO_SET_DI) {
947 			if (iface == 4)
948 				return 1; /* no analog input */
949 			if (altno != 2 && altno != 5)
950 				return 1; /* enable only altsets 2 and 5 */
951 		} else {
952 			if (iface == 5)
953 				return 1; /* disable digialt input */
954 			if (altno != 2 && altno != 5)
955 				return 1; /* enalbe only altsets 2 and 5 */
956 		}
957 	} else {
958 		/* keep only 16-Bit mode */
959 		if (altno != 1)
960 			return 1;
961 	}
962 
963 	usb_audio_dbg(chip,
964 		    "using altsetting %d for interface %d config %d\n",
965 		    altno, iface, chip->setup);
966 	return 0; /* keep this altsetting */
967 }
968 
snd_usb_apply_interface_quirk(struct snd_usb_audio * chip,int iface,int altno)969 int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,
970 				  int iface,
971 				  int altno)
972 {
973 	/* audiophile usb: skip altsets incompatible with device_setup */
974 	if (chip->usb_id == USB_ID(0x0763, 0x2003))
975 		return audiophile_skip_setting_quirk(chip, iface, altno);
976 	/* quattro usb: skip altsets incompatible with device_setup */
977 	if (chip->usb_id == USB_ID(0x0763, 0x2001))
978 		return quattro_skip_setting_quirk(chip, iface, altno);
979 	/* fasttrackpro usb: skip altsets incompatible with device_setup */
980 	if (chip->usb_id == USB_ID(0x0763, 0x2012))
981 		return fasttrackpro_skip_setting_quirk(chip, iface, altno);
982 
983 	return 0;
984 }
985 
snd_usb_apply_boot_quirk(struct usb_device * dev,struct usb_interface * intf,const struct snd_usb_audio_quirk * quirk,unsigned int id)986 int snd_usb_apply_boot_quirk(struct usb_device *dev,
987 			     struct usb_interface *intf,
988 			     const struct snd_usb_audio_quirk *quirk,
989 			     unsigned int id)
990 {
991 	switch (id) {
992 	case USB_ID(0x041e, 0x3000):
993 		/* SB Extigy needs special boot-up sequence */
994 		/* if more models come, this will go to the quirk list. */
995 		return snd_usb_extigy_boot_quirk(dev, intf);
996 
997 	case USB_ID(0x041e, 0x3020):
998 		/* SB Audigy 2 NX needs its own boot-up magic, too */
999 		return snd_usb_audigy2nx_boot_quirk(dev);
1000 
1001 	case USB_ID(0x10f5, 0x0200):
1002 		/* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
1003 		return snd_usb_cm106_boot_quirk(dev);
1004 
1005 	case USB_ID(0x0d8c, 0x0102):
1006 		/* C-Media CM6206 / CM106-Like Sound Device */
1007 	case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */
1008 		return snd_usb_cm6206_boot_quirk(dev);
1009 
1010 	case USB_ID(0x0dba, 0x3000):
1011 		/* Digidesign Mbox 2 */
1012 		return snd_usb_mbox2_boot_quirk(dev);
1013 
1014 	case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */
1015 	case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */
1016 		return snd_usb_novation_boot_quirk(dev);
1017 
1018 	case USB_ID(0x133e, 0x0815):
1019 		/* Access Music VirusTI Desktop */
1020 		return snd_usb_accessmusic_boot_quirk(dev);
1021 
1022 	case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */
1023 	case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */
1024 	case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */
1025 		return snd_usb_nativeinstruments_boot_quirk(dev);
1026 	case USB_ID(0x0763, 0x2012):  /* M-Audio Fast Track Pro USB */
1027 		return snd_usb_fasttrackpro_boot_quirk(dev);
1028 	case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */
1029 		return snd_usb_gamecon780_boot_quirk(dev);
1030 	}
1031 
1032 	return 0;
1033 }
1034 
1035 /*
1036  * check if the device uses big-endian samples
1037  */
snd_usb_is_big_endian_format(struct snd_usb_audio * chip,struct audioformat * fp)1038 int snd_usb_is_big_endian_format(struct snd_usb_audio *chip, struct audioformat *fp)
1039 {
1040 	/* it depends on altsetting whether the device is big-endian or not */
1041 	switch (chip->usb_id) {
1042 	case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
1043 		if (fp->altsetting == 2 || fp->altsetting == 3 ||
1044 			fp->altsetting == 5 || fp->altsetting == 6)
1045 			return 1;
1046 		break;
1047 	case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1048 		if (chip->setup == 0x00 ||
1049 			fp->altsetting == 1 || fp->altsetting == 2 ||
1050 			fp->altsetting == 3)
1051 			return 1;
1052 		break;
1053 	case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */
1054 		if (fp->altsetting == 2 || fp->altsetting == 3 ||
1055 			fp->altsetting == 5 || fp->altsetting == 6)
1056 			return 1;
1057 		break;
1058 	}
1059 	return 0;
1060 }
1061 
1062 /*
1063  * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,
1064  * not for interface.
1065  */
1066 
1067 enum {
1068 	EMU_QUIRK_SR_44100HZ = 0,
1069 	EMU_QUIRK_SR_48000HZ,
1070 	EMU_QUIRK_SR_88200HZ,
1071 	EMU_QUIRK_SR_96000HZ,
1072 	EMU_QUIRK_SR_176400HZ,
1073 	EMU_QUIRK_SR_192000HZ
1074 };
1075 
set_format_emu_quirk(struct snd_usb_substream * subs,struct audioformat * fmt)1076 static void set_format_emu_quirk(struct snd_usb_substream *subs,
1077 				 struct audioformat *fmt)
1078 {
1079 	unsigned char emu_samplerate_id = 0;
1080 
1081 	/* When capture is active
1082 	 * sample rate shouldn't be changed
1083 	 * by playback substream
1084 	 */
1085 	if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {
1086 		if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].interface != -1)
1087 			return;
1088 	}
1089 
1090 	switch (fmt->rate_min) {
1091 	case 48000:
1092 		emu_samplerate_id = EMU_QUIRK_SR_48000HZ;
1093 		break;
1094 	case 88200:
1095 		emu_samplerate_id = EMU_QUIRK_SR_88200HZ;
1096 		break;
1097 	case 96000:
1098 		emu_samplerate_id = EMU_QUIRK_SR_96000HZ;
1099 		break;
1100 	case 176400:
1101 		emu_samplerate_id = EMU_QUIRK_SR_176400HZ;
1102 		break;
1103 	case 192000:
1104 		emu_samplerate_id = EMU_QUIRK_SR_192000HZ;
1105 		break;
1106 	default:
1107 		emu_samplerate_id = EMU_QUIRK_SR_44100HZ;
1108 		break;
1109 	}
1110 	snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);
1111 	subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0;
1112 }
1113 
snd_usb_set_format_quirk(struct snd_usb_substream * subs,struct audioformat * fmt)1114 void snd_usb_set_format_quirk(struct snd_usb_substream *subs,
1115 			      struct audioformat *fmt)
1116 {
1117 	switch (subs->stream->chip->usb_id) {
1118 	case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1119 	case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1120 	case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1121 	case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
1122 		set_format_emu_quirk(subs, fmt);
1123 		break;
1124 	}
1125 }
1126 
snd_usb_get_sample_rate_quirk(struct snd_usb_audio * chip)1127 bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip)
1128 {
1129 	/* devices which do not support reading the sample rate. */
1130 	switch (chip->usb_id) {
1131 	case USB_ID(0x041E, 0x4080): /* Creative Live Cam VF0610 */
1132 	case USB_ID(0x045E, 0x075D): /* MS Lifecam Cinema  */
1133 	case USB_ID(0x045E, 0x076D): /* MS Lifecam HD-5000 */
1134 	case USB_ID(0x045E, 0x076E): /* MS Lifecam HD-5001 */
1135 	case USB_ID(0x045E, 0x076F): /* MS Lifecam HD-6000 */
1136 	case USB_ID(0x045E, 0x0772): /* MS Lifecam Studio */
1137 	case USB_ID(0x045E, 0x0779): /* MS Lifecam HD-3000 */
1138 	case USB_ID(0x047F, 0x02F7): /* Plantronics BT-600 */
1139 	case USB_ID(0x047F, 0x0415): /* Plantronics BT-300 */
1140 	case USB_ID(0x047F, 0xAA05): /* Plantronics DA45 */
1141 	case USB_ID(0x04D8, 0xFEEA): /* Benchmark DAC1 Pre */
1142 	case USB_ID(0x0556, 0x0014): /* Phoenix Audio TMX320VC */
1143 	case USB_ID(0x05A3, 0x9420): /* ELP HD USB Camera */
1144 	case USB_ID(0x074D, 0x3553): /* Outlaw RR2150 (Micronas UAC3553B) */
1145 	case USB_ID(0x1395, 0x740a): /* Sennheiser DECT */
1146 	case USB_ID(0x1901, 0x0191): /* GE B850V3 CP2114 audio interface */
1147 	case USB_ID(0x1de7, 0x0013): /* Phoenix Audio MT202exe */
1148 	case USB_ID(0x1de7, 0x0014): /* Phoenix Audio TMX320 */
1149 	case USB_ID(0x1de7, 0x0114): /* Phoenix Audio MT202pcs */
1150 	case USB_ID(0x21B4, 0x0081): /* AudioQuest DragonFly */
1151 		return true;
1152 	}
1153 	return false;
1154 }
1155 
1156 /* Marantz/Denon USB DACs need a vendor cmd to switch
1157  * between PCM and native DSD mode
1158  */
is_marantz_denon_dac(unsigned int id)1159 static bool is_marantz_denon_dac(unsigned int id)
1160 {
1161 	switch (id) {
1162 	case USB_ID(0x154e, 0x1003): /* Denon DA-300USB */
1163 	case USB_ID(0x154e, 0x3005): /* Marantz HD-DAC1 */
1164 	case USB_ID(0x154e, 0x3006): /* Marantz SA-14S1 */
1165 		return true;
1166 	}
1167 	return false;
1168 }
1169 
1170 /* TEAC UD-501/UD-503/NT-503 USB DACs need a vendor cmd to switch
1171  * between PCM/DOP and native DSD mode
1172  */
is_teac_dsd_dac(unsigned int id)1173 static bool is_teac_dsd_dac(unsigned int id)
1174 {
1175 	switch (id) {
1176 	case USB_ID(0x0644, 0x8043): /* TEAC UD-501/UD-503/NT-503 */
1177 	case USB_ID(0x0644, 0x8044): /* Esoteric D-05X */
1178 	case USB_ID(0x0644, 0x804a): /* TEAC UD-301 */
1179 		return true;
1180 	}
1181 	return false;
1182 }
1183 
snd_usb_select_mode_quirk(struct snd_usb_substream * subs,struct audioformat * fmt)1184 int snd_usb_select_mode_quirk(struct snd_usb_substream *subs,
1185 			      struct audioformat *fmt)
1186 {
1187 	struct usb_device *dev = subs->dev;
1188 	int err;
1189 
1190 	if (is_marantz_denon_dac(subs->stream->chip->usb_id)) {
1191 		/* First switch to alt set 0, otherwise the mode switch cmd
1192 		 * will not be accepted by the DAC
1193 		 */
1194 		err = usb_set_interface(dev, fmt->iface, 0);
1195 		if (err < 0)
1196 			return err;
1197 
1198 		mdelay(20); /* Delay needed after setting the interface */
1199 
1200 		switch (fmt->altsetting) {
1201 		case 2: /* DSD mode requested */
1202 		case 1: /* PCM mode requested */
1203 			err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1204 					      USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1205 					      fmt->altsetting - 1, 1, NULL, 0);
1206 			if (err < 0)
1207 				return err;
1208 			break;
1209 		}
1210 		mdelay(20);
1211 	} else if (is_teac_dsd_dac(subs->stream->chip->usb_id)) {
1212 		/* Vendor mode switch cmd is required. */
1213 		switch (fmt->altsetting) {
1214 		case 3: /* DSD mode (DSD_U32) requested */
1215 			err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1216 					      USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1217 					      1, 1, NULL, 0);
1218 			if (err < 0)
1219 				return err;
1220 			break;
1221 
1222 		case 2: /* PCM or DOP mode (S32) requested */
1223 		case 1: /* PCM mode (S16) requested */
1224 			err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,
1225 					      USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,
1226 					      0, 1, NULL, 0);
1227 			if (err < 0)
1228 				return err;
1229 			break;
1230 		}
1231 	}
1232 	return 0;
1233 }
1234 
snd_usb_endpoint_start_quirk(struct snd_usb_endpoint * ep)1235 void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep)
1236 {
1237 	/*
1238 	 * "Playback Design" products send bogus feedback data at the start
1239 	 * of the stream. Ignore them.
1240 	 */
1241 	if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba &&
1242 	    ep->type == SND_USB_ENDPOINT_TYPE_SYNC)
1243 		ep->skip_packets = 4;
1244 
1245 	/*
1246 	 * M-Audio Fast Track C400/C600 - when packets are not skipped, real
1247 	 * world latency varies by approx. +/- 50 frames (at 96KHz) each time
1248 	 * the stream is (re)started. When skipping packets 16 at endpoint
1249 	 * start up, the real world latency is stable within +/- 1 frame (also
1250 	 * across power cycles).
1251 	 */
1252 	if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) ||
1253 	     ep->chip->usb_id == USB_ID(0x0763, 0x2031)) &&
1254 	    ep->type == SND_USB_ENDPOINT_TYPE_DATA)
1255 		ep->skip_packets = 16;
1256 
1257 	/* Work around devices that report unreasonable feedback data */
1258 	if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) ||  /* TEAC UD-H01 */
1259 	     ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */
1260 	    ep->syncmaxsize == 4)
1261 		ep->tenor_fb_quirk = 1;
1262 }
1263 
snd_usb_set_interface_quirk(struct usb_device * dev)1264 void snd_usb_set_interface_quirk(struct usb_device *dev)
1265 {
1266 	struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1267 
1268 	if (!chip)
1269 		return;
1270 	/*
1271 	 * "Playback Design" products need a 50ms delay after setting the
1272 	 * USB interface.
1273 	 */
1274 	switch (USB_ID_VENDOR(chip->usb_id)) {
1275 	case 0x23ba: /* Playback Design */
1276 	case 0x0644: /* TEAC Corp. */
1277 		mdelay(50);
1278 		break;
1279 	}
1280 }
1281 
1282 /* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */
snd_usb_ctl_msg_quirk(struct usb_device * dev,unsigned int pipe,__u8 request,__u8 requesttype,__u16 value,__u16 index,void * data,__u16 size)1283 void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,
1284 			   __u8 request, __u8 requesttype, __u16 value,
1285 			   __u16 index, void *data, __u16 size)
1286 {
1287 	struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);
1288 
1289 	if (!chip)
1290 		return;
1291 	/*
1292 	 * "Playback Design" products need a 20ms delay after each
1293 	 * class compliant request
1294 	 */
1295 	if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&
1296 	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1297 		mdelay(20);
1298 
1299 	/*
1300 	 * "TEAC Corp." products need a 20ms delay after each
1301 	 * class compliant request
1302 	 */
1303 	if (USB_ID_VENDOR(chip->usb_id) == 0x0644 &&
1304 	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1305 		mdelay(20);
1306 
1307 	/* Marantz/Denon devices with USB DAC functionality need a delay
1308 	 * after each class compliant request
1309 	 */
1310 	if (is_marantz_denon_dac(chip->usb_id)
1311 	    && (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1312 		mdelay(20);
1313 
1314 	/* Zoom R16/24, Logitech H650e, Jabra 550a needs a tiny delay here,
1315 	 * otherwise requests like get/set frequency return as failed despite
1316 	 * actually succeeding.
1317 	 */
1318 	if ((chip->usb_id == USB_ID(0x1686, 0x00dd) ||
1319 	     chip->usb_id == USB_ID(0x046d, 0x0a46) ||
1320 	     chip->usb_id == USB_ID(0x0b0e, 0x0349)) &&
1321 	    (requesttype & USB_TYPE_MASK) == USB_TYPE_CLASS)
1322 		mdelay(1);
1323 }
1324 
1325 /*
1326  * snd_usb_interface_dsd_format_quirks() is called from format.c to
1327  * augment the PCM format bit-field for DSD types. The UAC standards
1328  * don't have a designated bit field to denote DSD-capable interfaces,
1329  * hence all hardware that is known to support this format has to be
1330  * listed here.
1331  */
snd_usb_interface_dsd_format_quirks(struct snd_usb_audio * chip,struct audioformat * fp,unsigned int sample_bytes)1332 u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,
1333 					struct audioformat *fp,
1334 					unsigned int sample_bytes)
1335 {
1336 	/* Playback Designs */
1337 	if (USB_ID_VENDOR(chip->usb_id) == 0x23ba) {
1338 		switch (fp->altsetting) {
1339 		case 1:
1340 			fp->dsd_dop = true;
1341 			return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1342 		case 2:
1343 			fp->dsd_bitrev = true;
1344 			return SNDRV_PCM_FMTBIT_DSD_U8;
1345 		case 3:
1346 			fp->dsd_bitrev = true;
1347 			return SNDRV_PCM_FMTBIT_DSD_U16_LE;
1348 		}
1349 	}
1350 
1351 	/* XMOS based USB DACs */
1352 	switch (chip->usb_id) {
1353 	case USB_ID(0x20b1, 0x3008): /* iFi Audio micro/nano iDSD */
1354 	case USB_ID(0x20b1, 0x2008): /* Matrix Audio X-Sabre */
1355 	case USB_ID(0x20b1, 0x300a): /* Matrix Audio Mini-i Pro */
1356 	case USB_ID(0x22d9, 0x0416): /* OPPO HA-1 */
1357 	case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */
1358 		if (fp->altsetting == 2)
1359 			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1360 		break;
1361 
1362 	case USB_ID(0x20b1, 0x000a): /* Gustard DAC-X20U */
1363 	case USB_ID(0x20b1, 0x2009): /* DIYINHK DSD DXD 384kHz USB to I2S/DSD */
1364 	case USB_ID(0x20b1, 0x2023): /* JLsounds I2SoverUSB */
1365 	case USB_ID(0x20b1, 0x3023): /* Aune X1S 32BIT/384 DSD DAC */
1366 	case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */
1367 		if (fp->altsetting == 3)
1368 			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1369 		break;
1370 	default:
1371 		break;
1372 	}
1373 
1374 	/* Denon/Marantz devices with USB DAC functionality */
1375 	if (is_marantz_denon_dac(chip->usb_id)) {
1376 		if (fp->altsetting == 2)
1377 			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1378 	}
1379 
1380 	/* TEAC devices with USB DAC functionality */
1381 	if (is_teac_dsd_dac(chip->usb_id)) {
1382 		if (fp->altsetting == 3)
1383 			return SNDRV_PCM_FMTBIT_DSD_U32_BE;
1384 	}
1385 
1386 	return 0;
1387 }
1388