1 // SPDX-License-Identifier: GPL-2.0-or-later
5 #include <linux/init.h>
6 #include <linux/slab.h>
8 #include <linux/usb/audio.h>
9 #include <linux/usb/midi.h>
10 #include <linux/bits.h>
12 #include <sound/control.h>
13 #include <sound/core.h>
14 #include <sound/info.h>
15 #include <sound/pcm.h>
20 #include "mixer_quirks.h"
30 * handle the quirks for the contained interfaces
32 static int create_composite_quirk(struct snd_usb_audio
*chip
,
33 struct usb_interface
*iface
,
34 struct usb_driver
*driver
,
35 const struct snd_usb_audio_quirk
*quirk_comp
)
37 int probed_ifnum
= get_iface_desc(iface
->altsetting
)->bInterfaceNumber
;
38 const struct snd_usb_audio_quirk
*quirk
;
41 for (quirk
= quirk_comp
->data
; quirk
->ifnum
>= 0; ++quirk
) {
42 iface
= usb_ifnum_to_if(chip
->dev
, quirk
->ifnum
);
45 if (quirk
->ifnum
!= probed_ifnum
&&
46 usb_interface_claimed(iface
))
48 err
= snd_usb_create_quirk(chip
, iface
, driver
, quirk
);
53 for (quirk
= quirk_comp
->data
; quirk
->ifnum
>= 0; ++quirk
) {
54 iface
= usb_ifnum_to_if(chip
->dev
, quirk
->ifnum
);
57 if (quirk
->ifnum
!= probed_ifnum
&&
58 !usb_interface_claimed(iface
)) {
59 err
= usb_driver_claim_interface(driver
, iface
,
60 USB_AUDIO_IFACE_UNUSED
);
69 static int ignore_interface_quirk(struct snd_usb_audio
*chip
,
70 struct usb_interface
*iface
,
71 struct usb_driver
*driver
,
72 const struct snd_usb_audio_quirk
*quirk
)
78 static int create_any_midi_quirk(struct snd_usb_audio
*chip
,
79 struct usb_interface
*intf
,
80 struct usb_driver
*driver
,
81 const struct snd_usb_audio_quirk
*quirk
)
83 return snd_usbmidi_create(chip
->card
, intf
, &chip
->midi_list
, quirk
);
87 * create a stream for an interface with proper descriptors
89 static int create_standard_audio_quirk(struct snd_usb_audio
*chip
,
90 struct usb_interface
*iface
,
91 struct usb_driver
*driver
,
92 const struct snd_usb_audio_quirk
*quirk
)
94 struct usb_host_interface
*alts
;
95 struct usb_interface_descriptor
*altsd
;
98 alts
= &iface
->altsetting
[0];
99 altsd
= get_iface_desc(alts
);
100 err
= snd_usb_parse_audio_interface(chip
, altsd
->bInterfaceNumber
);
102 usb_audio_err(chip
, "cannot setup if %d: error %d\n",
103 altsd
->bInterfaceNumber
, err
);
106 /* reset the current interface */
107 usb_set_interface(chip
->dev
, altsd
->bInterfaceNumber
, 0);
111 /* create the audio stream and the corresponding endpoints from the fixed
112 * audioformat object; this is used for quirks with the fixed EPs
114 static int add_audio_stream_from_fixed_fmt(struct snd_usb_audio
*chip
,
115 struct audioformat
*fp
)
119 stream
= (fp
->endpoint
& USB_DIR_IN
) ?
120 SNDRV_PCM_STREAM_CAPTURE
: SNDRV_PCM_STREAM_PLAYBACK
;
122 snd_usb_audioformat_set_sync_ep(chip
, fp
);
124 err
= snd_usb_add_audio_stream(chip
, stream
, fp
);
128 err
= snd_usb_add_endpoint(chip
, fp
->endpoint
,
129 SND_USB_ENDPOINT_TYPE_DATA
);
134 err
= snd_usb_add_endpoint(chip
, fp
->sync_ep
,
136 SND_USB_ENDPOINT_TYPE_DATA
:
137 SND_USB_ENDPOINT_TYPE_SYNC
);
146 * create a stream for an endpoint/altsetting without proper descriptors
148 static int create_fixed_stream_quirk(struct snd_usb_audio
*chip
,
149 struct usb_interface
*iface
,
150 struct usb_driver
*driver
,
151 const struct snd_usb_audio_quirk
*quirk
)
153 struct audioformat
*fp
;
154 struct usb_host_interface
*alts
;
155 struct usb_interface_descriptor
*altsd
;
156 unsigned *rate_table
= NULL
;
159 fp
= kmemdup(quirk
->data
, sizeof(*fp
), GFP_KERNEL
);
163 INIT_LIST_HEAD(&fp
->list
);
164 if (fp
->nr_rates
> MAX_NR_RATES
) {
168 if (fp
->nr_rates
> 0) {
169 rate_table
= kmemdup(fp
->rate_table
,
170 sizeof(int) * fp
->nr_rates
, GFP_KERNEL
);
175 fp
->rate_table
= rate_table
;
178 if (fp
->iface
!= get_iface_desc(&iface
->altsetting
[0])->bInterfaceNumber
||
179 fp
->altset_idx
>= iface
->num_altsetting
) {
183 alts
= &iface
->altsetting
[fp
->altset_idx
];
184 altsd
= get_iface_desc(alts
);
185 if (altsd
->bNumEndpoints
<= fp
->ep_idx
) {
190 fp
->protocol
= altsd
->bInterfaceProtocol
;
192 if (fp
->datainterval
== 0)
193 fp
->datainterval
= snd_usb_parse_datainterval(chip
, alts
);
194 if (fp
->maxpacksize
== 0)
195 fp
->maxpacksize
= le16_to_cpu(get_endpoint(alts
, fp
->ep_idx
)->wMaxPacketSize
);
197 fp
->fmt_type
= UAC_FORMAT_TYPE_I
;
199 err
= add_audio_stream_from_fixed_fmt(chip
, fp
);
203 usb_set_interface(chip
->dev
, fp
->iface
, 0);
204 snd_usb_init_pitch(chip
, fp
);
205 snd_usb_init_sample_rate(chip
, fp
, fp
->rate_max
);
209 list_del(&fp
->list
); /* unlink for avoiding double-free */
215 static int create_auto_pcm_quirk(struct snd_usb_audio
*chip
,
216 struct usb_interface
*iface
,
217 struct usb_driver
*driver
)
219 struct usb_host_interface
*alts
;
220 struct usb_interface_descriptor
*altsd
;
221 struct usb_endpoint_descriptor
*epd
;
222 struct uac1_as_header_descriptor
*ashd
;
223 struct uac_format_type_i_discrete_descriptor
*fmtd
;
226 * Most Roland/Yamaha audio streaming interfaces have more or less
227 * standard descriptors, but older devices might lack descriptors, and
228 * future ones might change, so ensure that we fail silently if the
229 * interface doesn't look exactly right.
232 /* must have a non-zero altsetting for streaming */
233 if (iface
->num_altsetting
< 2)
235 alts
= &iface
->altsetting
[1];
236 altsd
= get_iface_desc(alts
);
238 /* must have an isochronous endpoint for streaming */
239 if (altsd
->bNumEndpoints
< 1)
241 epd
= get_endpoint(alts
, 0);
242 if (!usb_endpoint_xfer_isoc(epd
))
245 /* must have format descriptors */
246 ashd
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
, NULL
,
248 fmtd
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
, NULL
,
250 if (!ashd
|| ashd
->bLength
< 7 ||
251 !fmtd
|| fmtd
->bLength
< 8)
254 return create_standard_audio_quirk(chip
, iface
, driver
, NULL
);
257 static int create_yamaha_midi_quirk(struct snd_usb_audio
*chip
,
258 struct usb_interface
*iface
,
259 struct usb_driver
*driver
,
260 struct usb_host_interface
*alts
)
262 static const struct snd_usb_audio_quirk yamaha_midi_quirk
= {
263 .type
= QUIRK_MIDI_YAMAHA
265 struct usb_midi_in_jack_descriptor
*injd
;
266 struct usb_midi_out_jack_descriptor
*outjd
;
268 /* must have some valid jack descriptors */
269 injd
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
270 NULL
, USB_MS_MIDI_IN_JACK
);
271 outjd
= snd_usb_find_csint_desc(alts
->extra
, alts
->extralen
,
272 NULL
, USB_MS_MIDI_OUT_JACK
);
275 if ((injd
&& !snd_usb_validate_midi_desc(injd
)) ||
276 (outjd
&& !snd_usb_validate_midi_desc(outjd
)))
278 if (injd
&& (injd
->bLength
< 5 ||
279 (injd
->bJackType
!= USB_MS_EMBEDDED
&&
280 injd
->bJackType
!= USB_MS_EXTERNAL
)))
282 if (outjd
&& (outjd
->bLength
< 6 ||
283 (outjd
->bJackType
!= USB_MS_EMBEDDED
&&
284 outjd
->bJackType
!= USB_MS_EXTERNAL
)))
286 return create_any_midi_quirk(chip
, iface
, driver
, &yamaha_midi_quirk
);
289 static int create_roland_midi_quirk(struct snd_usb_audio
*chip
,
290 struct usb_interface
*iface
,
291 struct usb_driver
*driver
,
292 struct usb_host_interface
*alts
)
294 static const struct snd_usb_audio_quirk roland_midi_quirk
= {
295 .type
= QUIRK_MIDI_ROLAND
297 u8
*roland_desc
= NULL
;
299 /* might have a vendor-specific descriptor <06 24 F1 02 ...> */
301 roland_desc
= snd_usb_find_csint_desc(alts
->extra
,
306 if (roland_desc
[0] < 6 || roland_desc
[3] != 2)
308 return create_any_midi_quirk(chip
, iface
, driver
,
313 static int create_std_midi_quirk(struct snd_usb_audio
*chip
,
314 struct usb_interface
*iface
,
315 struct usb_driver
*driver
,
316 struct usb_host_interface
*alts
)
318 struct usb_ms_header_descriptor
*mshd
;
319 struct usb_ms_endpoint_descriptor
*msepd
;
321 /* must have the MIDIStreaming interface header descriptor*/
322 mshd
= (struct usb_ms_header_descriptor
*)alts
->extra
;
323 if (alts
->extralen
< 7 ||
325 mshd
->bDescriptorType
!= USB_DT_CS_INTERFACE
||
326 mshd
->bDescriptorSubtype
!= USB_MS_HEADER
)
328 /* must have the MIDIStreaming endpoint descriptor*/
329 msepd
= (struct usb_ms_endpoint_descriptor
*)alts
->endpoint
[0].extra
;
330 if (alts
->endpoint
[0].extralen
< 4 ||
331 msepd
->bLength
< 4 ||
332 msepd
->bDescriptorType
!= USB_DT_CS_ENDPOINT
||
333 msepd
->bDescriptorSubtype
!= UAC_MS_GENERAL
||
334 msepd
->bNumEmbMIDIJack
< 1 ||
335 msepd
->bNumEmbMIDIJack
> 16)
338 return create_any_midi_quirk(chip
, iface
, driver
, NULL
);
341 static int create_auto_midi_quirk(struct snd_usb_audio
*chip
,
342 struct usb_interface
*iface
,
343 struct usb_driver
*driver
)
345 struct usb_host_interface
*alts
;
346 struct usb_interface_descriptor
*altsd
;
347 struct usb_endpoint_descriptor
*epd
;
350 alts
= &iface
->altsetting
[0];
351 altsd
= get_iface_desc(alts
);
353 /* must have at least one bulk/interrupt endpoint for streaming */
354 if (altsd
->bNumEndpoints
< 1)
356 epd
= get_endpoint(alts
, 0);
357 if (!usb_endpoint_xfer_bulk(epd
) &&
358 !usb_endpoint_xfer_int(epd
))
361 switch (USB_ID_VENDOR(chip
->usb_id
)) {
362 case 0x0499: /* Yamaha */
363 err
= create_yamaha_midi_quirk(chip
, iface
, driver
, alts
);
367 case 0x0582: /* Roland */
368 err
= create_roland_midi_quirk(chip
, iface
, driver
, alts
);
374 return create_std_midi_quirk(chip
, iface
, driver
, alts
);
377 static int create_autodetect_quirk(struct snd_usb_audio
*chip
,
378 struct usb_interface
*iface
,
379 struct usb_driver
*driver
)
383 err
= create_auto_pcm_quirk(chip
, iface
, driver
);
385 err
= create_auto_midi_quirk(chip
, iface
, driver
);
389 static int create_autodetect_quirks(struct snd_usb_audio
*chip
,
390 struct usb_interface
*iface
,
391 struct usb_driver
*driver
,
392 const struct snd_usb_audio_quirk
*quirk
)
394 int probed_ifnum
= get_iface_desc(iface
->altsetting
)->bInterfaceNumber
;
395 int ifcount
, ifnum
, err
;
397 err
= create_autodetect_quirk(chip
, iface
, driver
);
402 * ALSA PCM playback/capture devices cannot be registered in two steps,
403 * so we have to claim the other corresponding interface here.
405 ifcount
= chip
->dev
->actconfig
->desc
.bNumInterfaces
;
406 for (ifnum
= 0; ifnum
< ifcount
; ifnum
++) {
407 if (ifnum
== probed_ifnum
|| quirk
->ifnum
>= 0)
409 iface
= usb_ifnum_to_if(chip
->dev
, ifnum
);
411 usb_interface_claimed(iface
) ||
412 get_iface_desc(iface
->altsetting
)->bInterfaceClass
!=
413 USB_CLASS_VENDOR_SPEC
)
416 err
= create_autodetect_quirk(chip
, iface
, driver
);
418 err
= usb_driver_claim_interface(driver
, iface
,
419 USB_AUDIO_IFACE_UNUSED
);
429 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface.
430 * The only way to detect the sample rate is by looking at wMaxPacketSize.
432 static int create_uaxx_quirk(struct snd_usb_audio
*chip
,
433 struct usb_interface
*iface
,
434 struct usb_driver
*driver
,
435 const struct snd_usb_audio_quirk
*quirk
)
437 static const struct audioformat ua_format
= {
438 .formats
= SNDRV_PCM_FMTBIT_S24_3LE
,
440 .fmt_type
= UAC_FORMAT_TYPE_I
,
443 .rates
= SNDRV_PCM_RATE_CONTINUOUS
,
445 struct usb_host_interface
*alts
;
446 struct usb_interface_descriptor
*altsd
;
447 struct audioformat
*fp
;
450 /* both PCM and MIDI interfaces have 2 or more altsettings */
451 if (iface
->num_altsetting
< 2)
453 alts
= &iface
->altsetting
[1];
454 altsd
= get_iface_desc(alts
);
456 if (altsd
->bNumEndpoints
== 2) {
457 static const struct snd_usb_midi_endpoint_info ua700_ep
= {
458 .out_cables
= 0x0003,
461 static const struct snd_usb_audio_quirk ua700_quirk
= {
462 .type
= QUIRK_MIDI_FIXED_ENDPOINT
,
465 static const struct snd_usb_midi_endpoint_info uaxx_ep
= {
466 .out_cables
= 0x0001,
469 static const struct snd_usb_audio_quirk uaxx_quirk
= {
470 .type
= QUIRK_MIDI_FIXED_ENDPOINT
,
473 const struct snd_usb_audio_quirk
*quirk
=
474 chip
->usb_id
== USB_ID(0x0582, 0x002b)
475 ? &ua700_quirk
: &uaxx_quirk
;
476 return __snd_usbmidi_create(chip
->card
, iface
,
477 &chip
->midi_list
, quirk
,
481 if (altsd
->bNumEndpoints
!= 1)
484 fp
= kmemdup(&ua_format
, sizeof(*fp
), GFP_KERNEL
);
488 fp
->iface
= altsd
->bInterfaceNumber
;
489 fp
->endpoint
= get_endpoint(alts
, 0)->bEndpointAddress
;
490 fp
->ep_attr
= get_endpoint(alts
, 0)->bmAttributes
;
491 fp
->datainterval
= 0;
492 fp
->maxpacksize
= le16_to_cpu(get_endpoint(alts
, 0)->wMaxPacketSize
);
493 INIT_LIST_HEAD(&fp
->list
);
495 switch (fp
->maxpacksize
) {
497 fp
->rate_max
= fp
->rate_min
= 44100;
501 fp
->rate_max
= fp
->rate_min
= 48000;
505 fp
->rate_max
= fp
->rate_min
= 96000;
508 usb_audio_err(chip
, "unknown sample rate\n");
513 err
= add_audio_stream_from_fixed_fmt(chip
, fp
);
515 list_del(&fp
->list
); /* unlink for avoiding double-free */
519 usb_set_interface(chip
->dev
, fp
->iface
, 0);
524 * Create a standard mixer for the specified interface.
526 static int create_standard_mixer_quirk(struct snd_usb_audio
*chip
,
527 struct usb_interface
*iface
,
528 struct usb_driver
*driver
,
529 const struct snd_usb_audio_quirk
*quirk
)
531 if (quirk
->ifnum
< 0)
534 return snd_usb_create_mixer(chip
, quirk
->ifnum
);
538 * audio-interface quirks
540 * returns zero if no standard audio/MIDI parsing is needed.
541 * returns a positive value if standard audio/midi interfaces are parsed
543 * returns a negative value at error.
545 int snd_usb_create_quirk(struct snd_usb_audio
*chip
,
546 struct usb_interface
*iface
,
547 struct usb_driver
*driver
,
548 const struct snd_usb_audio_quirk
*quirk
)
550 typedef int (*quirk_func_t
)(struct snd_usb_audio
*,
551 struct usb_interface
*,
553 const struct snd_usb_audio_quirk
*);
554 static const quirk_func_t quirk_funcs
[] = {
555 [QUIRK_IGNORE_INTERFACE
] = ignore_interface_quirk
,
556 [QUIRK_COMPOSITE
] = create_composite_quirk
,
557 [QUIRK_AUTODETECT
] = create_autodetect_quirks
,
558 [QUIRK_MIDI_STANDARD_INTERFACE
] = create_any_midi_quirk
,
559 [QUIRK_MIDI_FIXED_ENDPOINT
] = create_any_midi_quirk
,
560 [QUIRK_MIDI_YAMAHA
] = create_any_midi_quirk
,
561 [QUIRK_MIDI_ROLAND
] = create_any_midi_quirk
,
562 [QUIRK_MIDI_MIDIMAN
] = create_any_midi_quirk
,
563 [QUIRK_MIDI_NOVATION
] = create_any_midi_quirk
,
564 [QUIRK_MIDI_RAW_BYTES
] = create_any_midi_quirk
,
565 [QUIRK_MIDI_EMAGIC
] = create_any_midi_quirk
,
566 [QUIRK_MIDI_CME
] = create_any_midi_quirk
,
567 [QUIRK_MIDI_AKAI
] = create_any_midi_quirk
,
568 [QUIRK_MIDI_FTDI
] = create_any_midi_quirk
,
569 [QUIRK_MIDI_CH345
] = create_any_midi_quirk
,
570 [QUIRK_AUDIO_STANDARD_INTERFACE
] = create_standard_audio_quirk
,
571 [QUIRK_AUDIO_FIXED_ENDPOINT
] = create_fixed_stream_quirk
,
572 [QUIRK_AUDIO_EDIROL_UAXX
] = create_uaxx_quirk
,
573 [QUIRK_AUDIO_STANDARD_MIXER
] = create_standard_mixer_quirk
,
576 if (quirk
->type
< QUIRK_TYPE_COUNT
) {
577 return quirk_funcs
[quirk
->type
](chip
, iface
, driver
, quirk
);
579 usb_audio_err(chip
, "invalid quirk type %d\n", quirk
->type
);
588 #define EXTIGY_FIRMWARE_SIZE_OLD 794
589 #define EXTIGY_FIRMWARE_SIZE_NEW 483
591 static int snd_usb_extigy_boot_quirk(struct usb_device
*dev
, struct usb_interface
*intf
)
593 struct usb_host_config
*config
= dev
->actconfig
;
596 if (le16_to_cpu(get_cfg_desc(config
)->wTotalLength
) == EXTIGY_FIRMWARE_SIZE_OLD
||
597 le16_to_cpu(get_cfg_desc(config
)->wTotalLength
) == EXTIGY_FIRMWARE_SIZE_NEW
) {
598 dev_dbg(&dev
->dev
, "sending Extigy boot sequence...\n");
599 /* Send message to force it to reconnect with full interface. */
600 err
= snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
,0),
601 0x10, 0x43, 0x0001, 0x000a, NULL
, 0);
603 dev_dbg(&dev
->dev
, "error sending boot message: %d\n", err
);
604 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0,
605 &dev
->descriptor
, sizeof(dev
->descriptor
));
606 config
= dev
->actconfig
;
608 dev_dbg(&dev
->dev
, "error usb_get_descriptor: %d\n", err
);
609 err
= usb_reset_configuration(dev
);
611 dev_dbg(&dev
->dev
, "error usb_reset_configuration: %d\n", err
);
612 dev_dbg(&dev
->dev
, "extigy_boot: new boot length = %d\n",
613 le16_to_cpu(get_cfg_desc(config
)->wTotalLength
));
614 return -ENODEV
; /* quit this anyway */
619 static int snd_usb_audigy2nx_boot_quirk(struct usb_device
*dev
)
623 snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), 0x2a,
624 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_OTHER
,
627 snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), 0x29,
628 USB_DIR_OUT
| USB_TYPE_VENDOR
| USB_RECIP_OTHER
,
635 static int snd_usb_fasttrackpro_boot_quirk(struct usb_device
*dev
)
639 if (dev
->actconfig
->desc
.bConfigurationValue
== 1) {
641 "Fast Track Pro switching to config #2\n");
642 /* This function has to be available by the usb core module.
643 * if it is not avialable the boot quirk has to be left out
644 * and the configuration has to be set by udev or hotplug
647 err
= usb_driver_set_configuration(dev
, 2);
650 "error usb_driver_set_configuration: %d\n",
652 /* Always return an error, so that we stop creating a device
653 that will just be destroyed and recreated with a new
657 dev_info(&dev
->dev
, "Fast Track Pro config OK\n");
663 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely
664 * documented in the device's data sheet.
666 static int snd_usb_cm106_write_int_reg(struct usb_device
*dev
, int reg
, u16 value
)
670 buf
[1] = value
& 0xff;
671 buf
[2] = (value
>> 8) & 0xff;
673 return snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), USB_REQ_SET_CONFIGURATION
,
674 USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
,
678 static int snd_usb_cm106_boot_quirk(struct usb_device
*dev
)
681 * Enable line-out driver mode, set headphone source to front
682 * channels, enable stereo mic.
684 return snd_usb_cm106_write_int_reg(dev
, 2, 0x8004);
688 * CM6206 registers from the CM6206 datasheet rev 2.1
690 #define CM6206_REG0_DMA_MASTER BIT(15)
691 #define CM6206_REG0_SPDIFO_RATE_48K (2 << 12)
692 #define CM6206_REG0_SPDIFO_RATE_96K (7 << 12)
693 /* Bit 4 thru 11 is the S/PDIF category code */
694 #define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4)
695 #define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3)
696 #define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2)
697 #define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1)
698 #define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0)
700 #define CM6206_REG1_TEST_SEL_CLK BIT(14)
701 #define CM6206_REG1_PLLBIN_EN BIT(13)
702 #define CM6206_REG1_SOFT_MUTE_EN BIT(12)
703 #define CM6206_REG1_GPIO4_OUT BIT(11)
704 #define CM6206_REG1_GPIO4_OE BIT(10)
705 #define CM6206_REG1_GPIO3_OUT BIT(9)
706 #define CM6206_REG1_GPIO3_OE BIT(8)
707 #define CM6206_REG1_GPIO2_OUT BIT(7)
708 #define CM6206_REG1_GPIO2_OE BIT(6)
709 #define CM6206_REG1_GPIO1_OUT BIT(5)
710 #define CM6206_REG1_GPIO1_OE BIT(4)
711 #define CM6206_REG1_SPDIFO_INVALID BIT(3)
712 #define CM6206_REG1_SPDIF_LOOP_EN BIT(2)
713 #define CM6206_REG1_SPDIFO_DIS BIT(1)
714 #define CM6206_REG1_SPDIFI_MIX BIT(0)
716 #define CM6206_REG2_DRIVER_ON BIT(15)
717 #define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13)
718 #define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13)
719 #define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13)
720 #define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13)
721 #define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12)
722 #define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11)
723 #define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10)
724 #define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9)
725 #define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8)
726 #define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7)
727 #define CM6206_REG2_MUTE_SUBWOOFER BIT(6)
728 #define CM6206_REG2_MUTE_CENTER BIT(5)
729 #define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3)
730 #define CM6206_REG2_MUTE_LEFT_FRONT BIT(3)
731 #define CM6206_REG2_EN_BTL BIT(2)
732 #define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0)
733 #define CM6206_REG2_MCUCLKSEL_3_MHZ (1)
734 #define CM6206_REG2_MCUCLKSEL_6_MHZ (2)
735 #define CM6206_REG2_MCUCLKSEL_12_MHZ (3)
737 /* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */
738 #define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11)
739 #define CM6206_REG3_VRAP25EN BIT(10)
740 #define CM6206_REG3_MSEL1 BIT(9)
741 #define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7)
742 #define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7)
743 #define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7)
744 #define CM6206_REG3_PINSEL BIT(6)
745 #define CM6206_REG3_FOE BIT(5)
746 #define CM6206_REG3_ROE BIT(4)
747 #define CM6206_REG3_CBOE BIT(3)
748 #define CM6206_REG3_LOSE BIT(2)
749 #define CM6206_REG3_HPOE BIT(1)
750 #define CM6206_REG3_SPDIFI_CANREC BIT(0)
752 #define CM6206_REG5_DA_RSTN BIT(13)
753 #define CM6206_REG5_AD_RSTN BIT(12)
754 #define CM6206_REG5_SPDIFO_AD2SPDO BIT(12)
755 #define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9)
756 #define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9)
757 #define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9)
758 #define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9)
759 #define CM6206_REG5_CODECM BIT(8)
760 #define CM6206_REG5_EN_HPF BIT(7)
761 #define CM6206_REG5_T_SEL_DSDA4 BIT(6)
762 #define CM6206_REG5_T_SEL_DSDA3 BIT(5)
763 #define CM6206_REG5_T_SEL_DSDA2 BIT(4)
764 #define CM6206_REG5_T_SEL_DSDA1 BIT(3)
765 #define CM6206_REG5_T_SEL_DSDAD_NORMAL 0
766 #define CM6206_REG5_T_SEL_DSDAD_FRONT 4
767 #define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5
768 #define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6
769 #define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7
771 static int snd_usb_cm6206_boot_quirk(struct usb_device
*dev
)
776 * Values here are chosen based on sniffing USB traffic
779 * REG0: DAC is master, sample rate 48kHz, no copyright
781 CM6206_REG0_SPDIFO_RATE_48K
|
782 CM6206_REG0_SPDIFO_COPYRIGHT_NA
,
784 * REG1: PLL binary search enable, soft mute enable.
786 CM6206_REG1_PLLBIN_EN
|
787 CM6206_REG1_SOFT_MUTE_EN
,
789 * REG2: enable output drivers,
790 * select front channels to the headphone output,
791 * then mute the headphone channels, run the MCU
794 CM6206_REG2_DRIVER_ON
|
795 CM6206_REG2_HEADP_SEL_FRONT_CHANNELS
|
796 CM6206_REG2_MUTE_HEADPHONE_RIGHT
|
797 CM6206_REG2_MUTE_HEADPHONE_LEFT
,
799 * REG3: default flyspeed, set 2.5V mic bias
800 * enable all line out ports and enable SPDIF
802 CM6206_REG3_FLYSPEED_DEFAULT
|
803 CM6206_REG3_VRAP25EN
|
809 CM6206_REG3_SPDIFI_CANREC
,
810 /* REG4 is just a bunch of GPIO lines */
812 /* REG5: de-assert AD/DA reset signals */
813 CM6206_REG5_DA_RSTN
|
814 CM6206_REG5_AD_RSTN
};
816 for (reg
= 0; reg
< ARRAY_SIZE(val
); reg
++) {
817 err
= snd_usb_cm106_write_int_reg(dev
, reg
, val
[reg
]);
825 /* quirk for Plantronics GameCom 780 with CM6302 chip */
826 static int snd_usb_gamecon780_boot_quirk(struct usb_device
*dev
)
828 /* set the initial volume and don't change; other values are either
829 * too loud or silent due to firmware bug (bko#65251)
831 u8 buf
[2] = { 0x74, 0xe3 };
832 return snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), UAC_SET_CUR
,
833 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_OUT
,
834 UAC_FU_VOLUME
<< 8, 9 << 8, buf
, 2);
838 * Novation Twitch DJ controller
839 * Focusrite Novation Saffire 6 USB audio card
841 static int snd_usb_novation_boot_quirk(struct usb_device
*dev
)
843 /* preemptively set up the device because otherwise the
844 * raw MIDI endpoints are not active */
845 usb_set_interface(dev
, 0, 1);
850 * This call will put the synth in "USB send" mode, i.e it will send MIDI
851 * messages through USB (this is disabled at startup). The synth will
852 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB
853 * sign on its LCD. Values here are chosen based on sniffing USB traffic
856 static int snd_usb_accessmusic_boot_quirk(struct usb_device
*dev
)
858 int err
, actual_length
;
859 /* "midi send" enable */
860 static const u8 seq
[] = { 0x4e, 0x73, 0x52, 0x01 };
863 if (usb_pipe_type_check(dev
, usb_sndintpipe(dev
, 0x05)))
865 buf
= kmemdup(seq
, ARRAY_SIZE(seq
), GFP_KERNEL
);
868 err
= usb_interrupt_msg(dev
, usb_sndintpipe(dev
, 0x05), buf
,
869 ARRAY_SIZE(seq
), &actual_length
, 1000);
878 * Some sound cards from Native Instruments are in fact compliant to the USB
879 * audio standard of version 2 and other approved USB standards, even though
880 * they come up as vendor-specific device when first connected.
882 * However, they can be told to come up with a new set of descriptors
883 * upon their next enumeration, and the interfaces announced by the new
884 * descriptors will then be handled by the kernel's class drivers. As the
885 * product ID will also change, no further checks are required.
888 static int snd_usb_nativeinstruments_boot_quirk(struct usb_device
*dev
)
892 ret
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
893 0xaf, USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
894 1, 0, NULL
, 0, 1000);
899 usb_reset_device(dev
);
901 /* return -EAGAIN, so the creation of an audio interface for this
902 * temporary device is aborted. The device will reconnect with a
907 static void mbox2_setup_48_24_magic(struct usb_device
*dev
)
912 /* Choose 48000Hz permanently */
917 /* Send the magic! */
918 snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0),
919 0x01, 0x22, 0x0100, 0x0085, &temp
, 0x0003);
920 snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0),
921 0x81, 0xa2, 0x0100, 0x0085, &srate
, 0x0003);
922 snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0),
923 0x81, 0xa2, 0x0100, 0x0086, &srate
, 0x0003);
924 snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0),
925 0x81, 0xa2, 0x0100, 0x0003, &srate
, 0x0003);
929 /* Digidesign Mbox 2 needs to load firmware onboard
930 * and driver must wait a few seconds for initialisation.
933 #define MBOX2_FIRMWARE_SIZE 646
934 #define MBOX2_BOOT_LOADING 0x01 /* Hard coded into the device */
935 #define MBOX2_BOOT_READY 0x02 /* Hard coded into the device */
937 static int snd_usb_mbox2_boot_quirk(struct usb_device
*dev
)
939 struct usb_host_config
*config
= dev
->actconfig
;
941 u8 bootresponse
[0x12];
945 fwsize
= le16_to_cpu(get_cfg_desc(config
)->wTotalLength
);
947 if (fwsize
!= MBOX2_FIRMWARE_SIZE
) {
948 dev_err(&dev
->dev
, "Invalid firmware size=%d.\n", fwsize
);
952 dev_dbg(&dev
->dev
, "Sending Digidesign Mbox 2 boot sequence...\n");
955 bootresponse
[0] = MBOX2_BOOT_LOADING
;
956 while ((bootresponse
[0] == MBOX2_BOOT_LOADING
) && (count
< 10)) {
957 msleep(500); /* 0.5 second delay */
958 snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0),
959 /* Control magic - load onboard firmware */
960 0x85, 0xc0, 0x0001, 0x0000, &bootresponse
, 0x0012);
961 if (bootresponse
[0] == MBOX2_BOOT_READY
)
963 dev_dbg(&dev
->dev
, "device not ready, resending boot sequence...\n");
967 if (bootresponse
[0] != MBOX2_BOOT_READY
) {
968 dev_err(&dev
->dev
, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse
[0]);
972 dev_dbg(&dev
->dev
, "device initialised!\n");
974 err
= usb_get_descriptor(dev
, USB_DT_DEVICE
, 0,
975 &dev
->descriptor
, sizeof(dev
->descriptor
));
976 config
= dev
->actconfig
;
978 dev_dbg(&dev
->dev
, "error usb_get_descriptor: %d\n", err
);
980 err
= usb_reset_configuration(dev
);
982 dev_dbg(&dev
->dev
, "error usb_reset_configuration: %d\n", err
);
983 dev_dbg(&dev
->dev
, "mbox2_boot: new boot length = %d\n",
984 le16_to_cpu(get_cfg_desc(config
)->wTotalLength
));
986 mbox2_setup_48_24_magic(dev
);
988 dev_info(&dev
->dev
, "Digidesign Mbox 2: 24bit 48kHz");
990 return 0; /* Successful boot */
993 static int snd_usb_axefx3_boot_quirk(struct usb_device
*dev
)
997 dev_dbg(&dev
->dev
, "Waiting for Axe-Fx III to boot up...\n");
999 /* If the Axe-Fx III has not fully booted, it will timeout when trying
1000 * to enable the audio streaming interface. A more generous timeout is
1001 * used here to detect when the Axe-Fx III has finished booting as the
1002 * set interface message will be acked once it has
1004 err
= usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
1005 USB_REQ_SET_INTERFACE
, USB_RECIP_INTERFACE
,
1006 1, 1, NULL
, 0, 120000);
1009 "failed waiting for Axe-Fx III to boot: %d\n", err
);
1013 dev_dbg(&dev
->dev
, "Axe-Fx III is now ready\n");
1015 err
= usb_set_interface(dev
, 1, 0);
1018 "error stopping Axe-Fx III interface: %d\n", err
);
1024 #define MICROBOOK_BUF_SIZE 128
1026 static int snd_usb_motu_microbookii_communicate(struct usb_device
*dev
, u8
*buf
,
1027 int buf_size
, int *length
)
1029 int err
, actual_length
;
1031 if (usb_pipe_type_check(dev
, usb_sndintpipe(dev
, 0x01)))
1033 err
= usb_interrupt_msg(dev
, usb_sndintpipe(dev
, 0x01), buf
, *length
,
1034 &actual_length
, 1000);
1038 print_hex_dump(KERN_DEBUG
, "MicroBookII snd: ", DUMP_PREFIX_NONE
, 16, 1,
1039 buf
, actual_length
, false);
1041 memset(buf
, 0, buf_size
);
1043 if (usb_pipe_type_check(dev
, usb_rcvintpipe(dev
, 0x82)))
1045 err
= usb_interrupt_msg(dev
, usb_rcvintpipe(dev
, 0x82), buf
, buf_size
,
1046 &actual_length
, 1000);
1050 print_hex_dump(KERN_DEBUG
, "MicroBookII rcv: ", DUMP_PREFIX_NONE
, 16, 1,
1051 buf
, actual_length
, false);
1053 *length
= actual_length
;
1057 static int snd_usb_motu_microbookii_boot_quirk(struct usb_device
*dev
)
1059 int err
, actual_length
, poll_attempts
= 0;
1060 static const u8 set_samplerate_seq
[] = { 0x00, 0x00, 0x00, 0x00,
1061 0x00, 0x00, 0x0b, 0x14,
1062 0x00, 0x00, 0x00, 0x01 };
1063 static const u8 poll_ready_seq
[] = { 0x00, 0x04, 0x00, 0x00,
1064 0x00, 0x00, 0x0b, 0x18 };
1065 u8
*buf
= kzalloc(MICROBOOK_BUF_SIZE
, GFP_KERNEL
);
1070 dev_info(&dev
->dev
, "Waiting for MOTU Microbook II to boot up...\n");
1072 /* First we tell the device which sample rate to use. */
1073 memcpy(buf
, set_samplerate_seq
, sizeof(set_samplerate_seq
));
1074 actual_length
= sizeof(set_samplerate_seq
);
1075 err
= snd_usb_motu_microbookii_communicate(dev
, buf
, MICROBOOK_BUF_SIZE
,
1080 "failed setting the sample rate for Motu MicroBook II: %d\n",
1085 /* Then we poll every 100 ms until the device informs of its readiness. */
1087 if (++poll_attempts
> 100) {
1089 "failed booting Motu MicroBook II: timeout\n");
1094 memset(buf
, 0, MICROBOOK_BUF_SIZE
);
1095 memcpy(buf
, poll_ready_seq
, sizeof(poll_ready_seq
));
1097 actual_length
= sizeof(poll_ready_seq
);
1098 err
= snd_usb_motu_microbookii_communicate(
1099 dev
, buf
, MICROBOOK_BUF_SIZE
, &actual_length
);
1102 "failed booting Motu MicroBook II: communication error %d\n",
1107 /* the device signals its readiness through a message of the
1109 * XX 06 00 00 00 00 0b 18 00 00 00 01
1110 * If the device is not yet ready to accept audio data, the
1111 * last byte of that sequence is 00.
1113 if (actual_length
== 12 && buf
[actual_length
- 1] == 1)
1119 dev_info(&dev
->dev
, "MOTU MicroBook II ready\n");
1126 static int snd_usb_motu_m_series_boot_quirk(struct usb_device
*dev
)
1136 #define MAUDIO_SET 0x01 /* parse device_setup */
1137 #define MAUDIO_SET_COMPATIBLE 0x80 /* use only "win-compatible" interfaces */
1138 #define MAUDIO_SET_DTS 0x02 /* enable DTS Digital Output */
1139 #define MAUDIO_SET_96K 0x04 /* 48-96kHz rate if set, 8-48kHz otherwise */
1140 #define MAUDIO_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */
1141 #define MAUDIO_SET_DI 0x10 /* enable Digital Input */
1142 #define MAUDIO_SET_MASK 0x1f /* bit mask for setup value */
1143 #define MAUDIO_SET_24B_48K_DI 0x19 /* 24bits+48kHz+Digital Input */
1144 #define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48kHz+No Digital Input */
1145 #define MAUDIO_SET_16B_48K_DI 0x11 /* 16bits+48kHz+Digital Input */
1146 #define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48kHz+No Digital Input */
1148 static int quattro_skip_setting_quirk(struct snd_usb_audio
*chip
,
1149 int iface
, int altno
)
1151 /* Reset ALL ifaces to 0 altsetting.
1152 * Call it for every possible altsetting of every interface.
1154 usb_set_interface(chip
->dev
, iface
, 0);
1155 if (chip
->setup
& MAUDIO_SET
) {
1156 if (chip
->setup
& MAUDIO_SET_COMPATIBLE
) {
1157 if (iface
!= 1 && iface
!= 2)
1158 return 1; /* skip all interfaces but 1 and 2 */
1161 if (iface
== 1 || iface
== 2)
1162 return 1; /* skip interfaces 1 and 2 */
1163 if ((chip
->setup
& MAUDIO_SET_96K
) && altno
!= 1)
1164 return 1; /* skip this altsetting */
1165 mask
= chip
->setup
& MAUDIO_SET_MASK
;
1166 if (mask
== MAUDIO_SET_24B_48K_DI
&& altno
!= 2)
1167 return 1; /* skip this altsetting */
1168 if (mask
== MAUDIO_SET_24B_48K_NOTDI
&& altno
!= 3)
1169 return 1; /* skip this altsetting */
1170 if (mask
== MAUDIO_SET_16B_48K_NOTDI
&& altno
!= 4)
1171 return 1; /* skip this altsetting */
1175 "using altsetting %d for interface %d config %d\n",
1176 altno
, iface
, chip
->setup
);
1177 return 0; /* keep this altsetting */
1180 static int audiophile_skip_setting_quirk(struct snd_usb_audio
*chip
,
1184 /* Reset ALL ifaces to 0 altsetting.
1185 * Call it for every possible altsetting of every interface.
1187 usb_set_interface(chip
->dev
, iface
, 0);
1189 if (chip
->setup
& MAUDIO_SET
) {
1191 if ((chip
->setup
& MAUDIO_SET_DTS
) && altno
!= 6)
1192 return 1; /* skip this altsetting */
1193 if ((chip
->setup
& MAUDIO_SET_96K
) && altno
!= 1)
1194 return 1; /* skip this altsetting */
1195 mask
= chip
->setup
& MAUDIO_SET_MASK
;
1196 if (mask
== MAUDIO_SET_24B_48K_DI
&& altno
!= 2)
1197 return 1; /* skip this altsetting */
1198 if (mask
== MAUDIO_SET_24B_48K_NOTDI
&& altno
!= 3)
1199 return 1; /* skip this altsetting */
1200 if (mask
== MAUDIO_SET_16B_48K_DI
&& altno
!= 4)
1201 return 1; /* skip this altsetting */
1202 if (mask
== MAUDIO_SET_16B_48K_NOTDI
&& altno
!= 5)
1203 return 1; /* skip this altsetting */
1206 return 0; /* keep this altsetting */
1209 static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio
*chip
,
1210 int iface
, int altno
)
1212 /* Reset ALL ifaces to 0 altsetting.
1213 * Call it for every possible altsetting of every interface.
1215 usb_set_interface(chip
->dev
, iface
, 0);
1217 /* possible configuration where both inputs and only one output is
1218 *used is not supported by the current setup
1220 if (chip
->setup
& (MAUDIO_SET
| MAUDIO_SET_24B
)) {
1221 if (chip
->setup
& MAUDIO_SET_96K
) {
1222 if (altno
!= 3 && altno
!= 6)
1224 } else if (chip
->setup
& MAUDIO_SET_DI
) {
1226 return 1; /* no analog input */
1227 if (altno
!= 2 && altno
!= 5)
1228 return 1; /* enable only altsets 2 and 5 */
1231 return 1; /* disable digialt input */
1232 if (altno
!= 2 && altno
!= 5)
1233 return 1; /* enalbe only altsets 2 and 5 */
1236 /* keep only 16-Bit mode */
1242 "using altsetting %d for interface %d config %d\n",
1243 altno
, iface
, chip
->setup
);
1244 return 0; /* keep this altsetting */
1247 static int s1810c_skip_setting_quirk(struct snd_usb_audio
*chip
,
1248 int iface
, int altno
)
1253 * Playback (Interface 1):
1254 * 1: 6 Analog + 2 S/PDIF
1255 * 2: 6 Analog + 2 S/PDIF
1258 * Capture (Interface 2):
1259 * 1: 8 Analog + 2 S/PDIF + 8 ADAT
1260 * 2: 8 Analog + 2 S/PDIF + 4 ADAT
1265 * I'll leave 2 as the default one and
1266 * use device_setup to switch to the
1269 if ((chip
->setup
== 0 || chip
->setup
> 2) && altno
!= 2)
1271 else if (chip
->setup
== 1 && altno
!= 1)
1273 else if (chip
->setup
== 2 && altno
!= 3)
1279 int snd_usb_apply_interface_quirk(struct snd_usb_audio
*chip
,
1283 /* audiophile usb: skip altsets incompatible with device_setup */
1284 if (chip
->usb_id
== USB_ID(0x0763, 0x2003))
1285 return audiophile_skip_setting_quirk(chip
, iface
, altno
);
1286 /* quattro usb: skip altsets incompatible with device_setup */
1287 if (chip
->usb_id
== USB_ID(0x0763, 0x2001))
1288 return quattro_skip_setting_quirk(chip
, iface
, altno
);
1289 /* fasttrackpro usb: skip altsets incompatible with device_setup */
1290 if (chip
->usb_id
== USB_ID(0x0763, 0x2012))
1291 return fasttrackpro_skip_setting_quirk(chip
, iface
, altno
);
1292 /* presonus studio 1810c: skip altsets incompatible with device_setup */
1293 if (chip
->usb_id
== USB_ID(0x0194f, 0x010c))
1294 return s1810c_skip_setting_quirk(chip
, iface
, altno
);
1300 int snd_usb_apply_boot_quirk(struct usb_device
*dev
,
1301 struct usb_interface
*intf
,
1302 const struct snd_usb_audio_quirk
*quirk
,
1306 case USB_ID(0x041e, 0x3000):
1307 /* SB Extigy needs special boot-up sequence */
1308 /* if more models come, this will go to the quirk list. */
1309 return snd_usb_extigy_boot_quirk(dev
, intf
);
1311 case USB_ID(0x041e, 0x3020):
1312 /* SB Audigy 2 NX needs its own boot-up magic, too */
1313 return snd_usb_audigy2nx_boot_quirk(dev
);
1315 case USB_ID(0x10f5, 0x0200):
1316 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */
1317 return snd_usb_cm106_boot_quirk(dev
);
1319 case USB_ID(0x0d8c, 0x0102):
1320 /* C-Media CM6206 / CM106-Like Sound Device */
1321 case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */
1322 return snd_usb_cm6206_boot_quirk(dev
);
1324 case USB_ID(0x0dba, 0x3000):
1325 /* Digidesign Mbox 2 */
1326 return snd_usb_mbox2_boot_quirk(dev
);
1328 case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */
1329 case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */
1330 return snd_usb_novation_boot_quirk(dev
);
1332 case USB_ID(0x133e, 0x0815):
1333 /* Access Music VirusTI Desktop */
1334 return snd_usb_accessmusic_boot_quirk(dev
);
1336 case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */
1337 case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */
1338 case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */
1339 return snd_usb_nativeinstruments_boot_quirk(dev
);
1340 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */
1341 return snd_usb_fasttrackpro_boot_quirk(dev
);
1342 case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */
1343 return snd_usb_gamecon780_boot_quirk(dev
);
1344 case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */
1345 return snd_usb_axefx3_boot_quirk(dev
);
1346 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */
1348 * For some reason interface 3 with vendor-spec class is
1349 * detected on MicroBook IIc.
1351 if (get_iface_desc(intf
->altsetting
)->bInterfaceClass
==
1352 USB_CLASS_VENDOR_SPEC
&&
1353 get_iface_desc(intf
->altsetting
)->bInterfaceNumber
< 3)
1354 return snd_usb_motu_microbookii_boot_quirk(dev
);
1361 int snd_usb_apply_boot_quirk_once(struct usb_device
*dev
,
1362 struct usb_interface
*intf
,
1363 const struct snd_usb_audio_quirk
*quirk
,
1367 case USB_ID(0x07fd, 0x0008): /* MOTU M Series */
1368 return snd_usb_motu_m_series_boot_quirk(dev
);
1375 * check if the device uses big-endian samples
1377 int snd_usb_is_big_endian_format(struct snd_usb_audio
*chip
,
1378 const struct audioformat
*fp
)
1380 /* it depends on altsetting whether the device is big-endian or not */
1381 switch (chip
->usb_id
) {
1382 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */
1383 if (fp
->altsetting
== 2 || fp
->altsetting
== 3 ||
1384 fp
->altsetting
== 5 || fp
->altsetting
== 6)
1387 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1388 if (chip
->setup
== 0x00 ||
1389 fp
->altsetting
== 1 || fp
->altsetting
== 2 ||
1390 fp
->altsetting
== 3)
1393 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */
1394 if (fp
->altsetting
== 2 || fp
->altsetting
== 3 ||
1395 fp
->altsetting
== 5 || fp
->altsetting
== 6)
1403 * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,
1404 * not for interface.
1408 EMU_QUIRK_SR_44100HZ
= 0,
1409 EMU_QUIRK_SR_48000HZ
,
1410 EMU_QUIRK_SR_88200HZ
,
1411 EMU_QUIRK_SR_96000HZ
,
1412 EMU_QUIRK_SR_176400HZ
,
1413 EMU_QUIRK_SR_192000HZ
1416 static void set_format_emu_quirk(struct snd_usb_substream
*subs
,
1417 const struct audioformat
*fmt
)
1419 unsigned char emu_samplerate_id
= 0;
1421 /* When capture is active
1422 * sample rate shouldn't be changed
1423 * by playback substream
1425 if (subs
->direction
== SNDRV_PCM_STREAM_PLAYBACK
) {
1426 if (subs
->stream
->substream
[SNDRV_PCM_STREAM_CAPTURE
].cur_audiofmt
)
1430 switch (fmt
->rate_min
) {
1432 emu_samplerate_id
= EMU_QUIRK_SR_48000HZ
;
1435 emu_samplerate_id
= EMU_QUIRK_SR_88200HZ
;
1438 emu_samplerate_id
= EMU_QUIRK_SR_96000HZ
;
1441 emu_samplerate_id
= EMU_QUIRK_SR_176400HZ
;
1444 emu_samplerate_id
= EMU_QUIRK_SR_192000HZ
;
1447 emu_samplerate_id
= EMU_QUIRK_SR_44100HZ
;
1450 snd_emuusb_set_samplerate(subs
->stream
->chip
, emu_samplerate_id
);
1451 subs
->pkt_offset_adj
= (emu_samplerate_id
>= EMU_QUIRK_SR_176400HZ
) ? 4 : 0;
1454 static int pioneer_djm_set_format_quirk(struct snd_usb_substream
*subs
,
1457 unsigned int cur_rate
= subs
->data_endpoint
->cur_rate
;
1459 // Convert to little endian
1460 sr
[0] = cur_rate
& 0xff;
1461 sr
[1] = (cur_rate
>> 8) & 0xff;
1462 sr
[2] = (cur_rate
>> 16) & 0xff;
1463 usb_set_interface(subs
->dev
, 0, 1);
1464 // we should derive windex from fmt-sync_ep but it's not set
1465 snd_usb_ctl_msg(subs
->stream
->chip
->dev
,
1466 usb_sndctrlpipe(subs
->stream
->chip
->dev
, 0),
1467 0x01, 0x22, 0x0100, windex
, &sr
, 0x0003);
1471 void snd_usb_set_format_quirk(struct snd_usb_substream
*subs
,
1472 const struct audioformat
*fmt
)
1474 switch (subs
->stream
->chip
->usb_id
) {
1475 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */
1476 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */
1477 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */
1478 case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */
1479 set_format_emu_quirk(subs
, fmt
);
1481 case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */
1482 subs
->stream_offset_adj
= 2;
1484 case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */
1485 pioneer_djm_set_format_quirk(subs
, 0x0082);
1487 case USB_ID(0x08e4, 0x017f): /* Pioneer DJM-750 */
1488 case USB_ID(0x08e4, 0x0163): /* Pioneer DJM-850 */
1489 pioneer_djm_set_format_quirk(subs
, 0x0086);
1494 int snd_usb_select_mode_quirk(struct snd_usb_audio
*chip
,
1495 const struct audioformat
*fmt
)
1497 struct usb_device
*dev
= chip
->dev
;
1500 if (chip
->quirk_flags
& QUIRK_FLAG_ITF_USB_DSD_DAC
) {
1501 /* First switch to alt set 0, otherwise the mode switch cmd
1502 * will not be accepted by the DAC
1504 err
= usb_set_interface(dev
, fmt
->iface
, 0);
1508 msleep(20); /* Delay needed after setting the interface */
1510 /* Vendor mode switch cmd is required. */
1511 if (fmt
->formats
& SNDRV_PCM_FMTBIT_DSD_U32_BE
) {
1512 /* DSD mode (DSD_U32) requested */
1513 err
= snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), 0,
1514 USB_DIR_OUT
|USB_TYPE_VENDOR
|USB_RECIP_INTERFACE
,
1520 /* PCM or DOP mode (S32) requested */
1521 /* PCM mode (S16) requested */
1522 err
= snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), 0,
1523 USB_DIR_OUT
|USB_TYPE_VENDOR
|USB_RECIP_INTERFACE
,
1534 void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint
*ep
)
1537 * "Playback Design" products send bogus feedback data at the start
1538 * of the stream. Ignore them.
1540 if (USB_ID_VENDOR(ep
->chip
->usb_id
) == 0x23ba &&
1541 ep
->type
== SND_USB_ENDPOINT_TYPE_SYNC
)
1542 ep
->skip_packets
= 4;
1545 * M-Audio Fast Track C400/C600 - when packets are not skipped, real
1546 * world latency varies by approx. +/- 50 frames (at 96kHz) each time
1547 * the stream is (re)started. When skipping packets 16 at endpoint
1548 * start up, the real world latency is stable within +/- 1 frame (also
1549 * across power cycles).
1551 if ((ep
->chip
->usb_id
== USB_ID(0x0763, 0x2030) ||
1552 ep
->chip
->usb_id
== USB_ID(0x0763, 0x2031)) &&
1553 ep
->type
== SND_USB_ENDPOINT_TYPE_DATA
)
1554 ep
->skip_packets
= 16;
1556 /* Work around devices that report unreasonable feedback data */
1557 if ((ep
->chip
->usb_id
== USB_ID(0x0644, 0x8038) || /* TEAC UD-H01 */
1558 ep
->chip
->usb_id
== USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */
1559 ep
->syncmaxsize
== 4)
1560 ep
->tenor_fb_quirk
= 1;
1563 /* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */
1564 void snd_usb_ctl_msg_quirk(struct usb_device
*dev
, unsigned int pipe
,
1565 __u8 request
, __u8 requesttype
, __u16 value
,
1566 __u16 index
, void *data
, __u16 size
)
1568 struct snd_usb_audio
*chip
= dev_get_drvdata(&dev
->dev
);
1570 if (!chip
|| (requesttype
& USB_TYPE_MASK
) != USB_TYPE_CLASS
)
1573 if (chip
->quirk_flags
& QUIRK_FLAG_CTL_MSG_DELAY
)
1575 else if (chip
->quirk_flags
& QUIRK_FLAG_CTL_MSG_DELAY_1M
)
1576 usleep_range(1000, 2000);
1577 else if (chip
->quirk_flags
& QUIRK_FLAG_CTL_MSG_DELAY_5M
)
1578 usleep_range(5000, 6000);
1582 * snd_usb_interface_dsd_format_quirks() is called from format.c to
1583 * augment the PCM format bit-field for DSD types. The UAC standards
1584 * don't have a designated bit field to denote DSD-capable interfaces,
1585 * hence all hardware that is known to support this format has to be
1588 u64
snd_usb_interface_dsd_format_quirks(struct snd_usb_audio
*chip
,
1589 struct audioformat
*fp
,
1590 unsigned int sample_bytes
)
1592 struct usb_interface
*iface
;
1594 /* Playback Designs */
1595 if (USB_ID_VENDOR(chip
->usb_id
) == 0x23ba &&
1596 USB_ID_PRODUCT(chip
->usb_id
) < 0x0110) {
1597 switch (fp
->altsetting
) {
1600 return SNDRV_PCM_FMTBIT_DSD_U16_LE
;
1602 fp
->dsd_bitrev
= true;
1603 return SNDRV_PCM_FMTBIT_DSD_U8
;
1605 fp
->dsd_bitrev
= true;
1606 return SNDRV_PCM_FMTBIT_DSD_U16_LE
;
1610 /* XMOS based USB DACs */
1611 switch (chip
->usb_id
) {
1612 case USB_ID(0x1511, 0x0037): /* AURALiC VEGA */
1613 case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */
1614 case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */
1615 if (fp
->altsetting
== 2)
1616 return SNDRV_PCM_FMTBIT_DSD_U32_BE
;
1619 case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */
1620 case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */
1621 case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */
1622 case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */
1623 case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */
1624 case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */
1625 case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */
1626 case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */
1627 case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */
1628 case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */
1629 case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */
1630 case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */
1631 case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */
1632 case USB_ID(0x6b42, 0x0042): /* MSB Technology */
1633 if (fp
->altsetting
== 3)
1634 return SNDRV_PCM_FMTBIT_DSD_U32_BE
;
1637 /* Amanero Combo384 USB based DACs with native DSD support */
1638 case USB_ID(0x16d0, 0x071a): /* Amanero - Combo384 */
1639 case USB_ID(0x2ab6, 0x0004): /* T+A DAC8DSD-V2.0, MP1000E-V2.0, MP2000R-V2.0, MP2500R-V2.0, MP3100HV-V2.0 */
1640 case USB_ID(0x2ab6, 0x0005): /* T+A USB HD Audio 1 */
1641 case USB_ID(0x2ab6, 0x0006): /* T+A USB HD Audio 2 */
1642 if (fp
->altsetting
== 2) {
1643 switch (le16_to_cpu(chip
->dev
->descriptor
.bcdDevice
)) {
1645 return SNDRV_PCM_FMTBIT_DSD_U32_LE
;
1648 return SNDRV_PCM_FMTBIT_DSD_U32_BE
;
1654 case USB_ID(0x16d0, 0x0a23):
1655 if (fp
->altsetting
== 2)
1656 return SNDRV_PCM_FMTBIT_DSD_U32_BE
;
1663 /* ITF-USB DSD based DACs */
1664 if (chip
->quirk_flags
& QUIRK_FLAG_ITF_USB_DSD_DAC
) {
1665 iface
= usb_ifnum_to_if(chip
->dev
, fp
->iface
);
1667 /* Altsetting 2 support native DSD if the num of altsets is
1669 * Altsetting 3 support native DSD if the num of altsets is
1672 if (fp
->altsetting
== iface
->num_altsetting
- 1)
1673 return SNDRV_PCM_FMTBIT_DSD_U32_BE
;
1676 /* Mostly generic method to detect many DSD-capable implementations */
1677 if ((chip
->quirk_flags
& QUIRK_FLAG_DSD_RAW
) && fp
->dsd_raw
)
1678 return SNDRV_PCM_FMTBIT_DSD_U32_BE
;
1683 void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio
*chip
,
1684 struct audioformat
*fp
,
1687 switch (chip
->usb_id
) {
1688 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */
1689 /* Optoplay sets the sample rate attribute although
1690 * it seems not supporting it in fact.
1692 fp
->attributes
&= ~UAC_EP_CS_ATTR_SAMPLE_RATE
;
1694 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */
1695 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */
1696 /* doesn't set the sample rate attribute, but supports it */
1697 fp
->attributes
|= UAC_EP_CS_ATTR_SAMPLE_RATE
;
1699 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */
1700 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */
1701 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */
1702 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is
1703 an older model 77d:223) */
1705 * plantronics headset and Griffin iMic have set adaptive-in
1706 * although it's really not...
1708 fp
->ep_attr
&= ~USB_ENDPOINT_SYNCTYPE
;
1709 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1710 fp
->ep_attr
|= USB_ENDPOINT_SYNC_ADAPTIVE
;
1712 fp
->ep_attr
|= USB_ENDPOINT_SYNC_SYNC
;
1714 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook IIc */
1716 * MaxPacketsOnly attribute is erroneously set in endpoint
1717 * descriptors. As a result this card produces noise with
1718 * all sample rates other than 96 kHz.
1720 fp
->attributes
&= ~UAC_EP_CS_ATTR_FILL_MAX
;
1722 case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */
1723 /* mic works only when ep packet size is set to wMaxPacketSize */
1724 fp
->attributes
|= UAC_EP_CS_ATTR_FILL_MAX
;
1731 * registration quirk:
1732 * the registration is skipped if a device matches with the given ID,
1733 * unless the interface reaches to the defined one. This is for delaying
1734 * the registration until the last known interface, so that the card and
1735 * devices appear at the same time.
1738 struct registration_quirk
{
1739 unsigned int usb_id
; /* composed via USB_ID() */
1740 unsigned int interface
; /* the interface to trigger register */
1743 #define REG_QUIRK_ENTRY(vendor, product, iface) \
1744 { .usb_id = USB_ID(vendor, product), .interface = (iface) }
1746 static const struct registration_quirk registration_quirks
[] = {
1747 REG_QUIRK_ENTRY(0x0951, 0x16d8, 2), /* Kingston HyperX AMP */
1748 REG_QUIRK_ENTRY(0x0951, 0x16ed, 2), /* Kingston HyperX Cloud Alpha S */
1749 REG_QUIRK_ENTRY(0x0951, 0x16ea, 2), /* Kingston HyperX Cloud Flight S */
1750 REG_QUIRK_ENTRY(0x0ecb, 0x1f46, 2), /* JBL Quantum 600 */
1751 REG_QUIRK_ENTRY(0x0ecb, 0x1f47, 2), /* JBL Quantum 800 */
1752 REG_QUIRK_ENTRY(0x0ecb, 0x2039, 2), /* JBL Quantum 400 */
1753 REG_QUIRK_ENTRY(0x0ecb, 0x203c, 2), /* JBL Quantum 600 */
1754 REG_QUIRK_ENTRY(0x0ecb, 0x203e, 2), /* JBL Quantum 800 */
1755 { 0 } /* terminator */
1758 /* return true if skipping registration */
1759 bool snd_usb_registration_quirk(struct snd_usb_audio
*chip
, int iface
)
1761 const struct registration_quirk
*q
;
1763 for (q
= registration_quirks
; q
->usb_id
; q
++)
1764 if (chip
->usb_id
== q
->usb_id
)
1765 return iface
!= q
->interface
;
1767 /* Register as normal */
1772 * driver behavior quirk flags
1774 struct usb_audio_quirk_flags_table
{
1779 #define DEVICE_FLG(vid, pid, _flags) \
1780 { .id = USB_ID(vid, pid), .flags = (_flags) }
1781 #define VENDOR_FLG(vid, _flags) DEVICE_FLG(vid, 0, _flags)
1783 static const struct usb_audio_quirk_flags_table quirk_flags_table
[] = {
1784 /* Device matches */
1785 DEVICE_FLG(0x041e, 0x3000, /* Creative SB Extigy */
1786 QUIRK_FLAG_IGNORE_CTL_ERROR
),
1787 DEVICE_FLG(0x041e, 0x4080, /* Creative Live Cam VF0610 */
1788 QUIRK_FLAG_GET_SAMPLE_RATE
),
1789 DEVICE_FLG(0x046d, 0x084c, /* Logitech ConferenceCam Connect */
1790 QUIRK_FLAG_GET_SAMPLE_RATE
| QUIRK_FLAG_CTL_MSG_DELAY_1M
),
1791 DEVICE_FLG(0x046d, 0x0991, /* Logitech QuickCam Pro */
1792 QUIRK_FLAG_CTL_MSG_DELAY_1M
| QUIRK_FLAG_IGNORE_CTL_ERROR
),
1793 DEVICE_FLG(0x046d, 0x09a4, /* Logitech QuickCam E 3500 */
1794 QUIRK_FLAG_CTL_MSG_DELAY_1M
| QUIRK_FLAG_IGNORE_CTL_ERROR
),
1795 DEVICE_FLG(0x04d8, 0xfeea, /* Benchmark DAC1 Pre */
1796 QUIRK_FLAG_GET_SAMPLE_RATE
),
1797 DEVICE_FLG(0x04e8, 0xa051, /* Samsung USBC Headset (AKG) */
1798 QUIRK_FLAG_SKIP_CLOCK_SELECTOR
| QUIRK_FLAG_CTL_MSG_DELAY_5M
),
1799 DEVICE_FLG(0x054c, 0x0b8c, /* Sony WALKMAN NW-A45 DAC */
1800 QUIRK_FLAG_SET_IFACE_FIRST
),
1801 DEVICE_FLG(0x0556, 0x0014, /* Phoenix Audio TMX320VC */
1802 QUIRK_FLAG_GET_SAMPLE_RATE
),
1803 DEVICE_FLG(0x05a3, 0x9420, /* ELP HD USB Camera */
1804 QUIRK_FLAG_GET_SAMPLE_RATE
),
1805 DEVICE_FLG(0x05a7, 0x1020, /* Bose Companion 5 */
1806 QUIRK_FLAG_GET_SAMPLE_RATE
),
1807 DEVICE_FLG(0x05e1, 0x0408, /* Syntek STK1160 */
1808 QUIRK_FLAG_ALIGN_TRANSFER
),
1809 DEVICE_FLG(0x05e1, 0x0480, /* Hauppauge Woodbury */
1810 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1811 DEVICE_FLG(0x0644, 0x8043, /* TEAC UD-501/UD-501V2/UD-503/NT-503 */
1812 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
|
1813 QUIRK_FLAG_IFACE_DELAY
),
1814 DEVICE_FLG(0x0644, 0x8044, /* Esoteric D-05X */
1815 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
|
1816 QUIRK_FLAG_IFACE_DELAY
),
1817 DEVICE_FLG(0x0644, 0x804a, /* TEAC UD-301 */
1818 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
|
1819 QUIRK_FLAG_IFACE_DELAY
),
1820 DEVICE_FLG(0x06f8, 0xb000, /* Hercules DJ Console (Windows Edition) */
1821 QUIRK_FLAG_IGNORE_CTL_ERROR
),
1822 DEVICE_FLG(0x06f8, 0xd002, /* Hercules DJ Console (Macintosh Edition) */
1823 QUIRK_FLAG_IGNORE_CTL_ERROR
),
1824 DEVICE_FLG(0x074d, 0x3553, /* Outlaw RR2150 (Micronas UAC3553B) */
1825 QUIRK_FLAG_GET_SAMPLE_RATE
),
1826 DEVICE_FLG(0x08bb, 0x2702, /* LineX FM Transmitter */
1827 QUIRK_FLAG_IGNORE_CTL_ERROR
),
1828 DEVICE_FLG(0x0951, 0x16ad, /* Kingston HyperX */
1829 QUIRK_FLAG_CTL_MSG_DELAY_1M
),
1830 DEVICE_FLG(0x0b0e, 0x0349, /* Jabra 550a */
1831 QUIRK_FLAG_CTL_MSG_DELAY_1M
),
1832 DEVICE_FLG(0x0fd9, 0x0008, /* Hauppauge HVR-950Q */
1833 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1834 DEVICE_FLG(0x1395, 0x740a, /* Sennheiser DECT */
1835 QUIRK_FLAG_GET_SAMPLE_RATE
),
1836 DEVICE_FLG(0x13e5, 0x0001, /* Serato Phono */
1837 QUIRK_FLAG_IGNORE_CTL_ERROR
),
1838 DEVICE_FLG(0x154e, 0x1002, /* Denon DCD-1500RE */
1839 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
),
1840 DEVICE_FLG(0x154e, 0x1003, /* Denon DA-300USB */
1841 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
),
1842 DEVICE_FLG(0x154e, 0x3005, /* Marantz HD-DAC1 */
1843 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
),
1844 DEVICE_FLG(0x154e, 0x3006, /* Marantz SA-14S1 */
1845 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
),
1846 DEVICE_FLG(0x154e, 0x500e, /* Denon DN-X1600 */
1847 QUIRK_FLAG_IGNORE_CLOCK_SOURCE
),
1848 DEVICE_FLG(0x1686, 0x00dd, /* Zoom R16/24 */
1849 QUIRK_FLAG_TX_LENGTH
| QUIRK_FLAG_CTL_MSG_DELAY_1M
),
1850 DEVICE_FLG(0x17aa, 0x1046, /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */
1851 QUIRK_FLAG_DISABLE_AUTOSUSPEND
),
1852 DEVICE_FLG(0x17aa, 0x104d, /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */
1853 QUIRK_FLAG_DISABLE_AUTOSUSPEND
),
1854 DEVICE_FLG(0x1852, 0x5065, /* Luxman DA-06 */
1855 QUIRK_FLAG_ITF_USB_DSD_DAC
| QUIRK_FLAG_CTL_MSG_DELAY
),
1856 DEVICE_FLG(0x1901, 0x0191, /* GE B850V3 CP2114 audio interface */
1857 QUIRK_FLAG_GET_SAMPLE_RATE
),
1858 DEVICE_FLG(0x2040, 0x7200, /* Hauppauge HVR-950Q */
1859 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1860 DEVICE_FLG(0x2040, 0x7201, /* Hauppauge HVR-950Q-MXL */
1861 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1862 DEVICE_FLG(0x2040, 0x7210, /* Hauppauge HVR-950Q */
1863 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1864 DEVICE_FLG(0x2040, 0x7211, /* Hauppauge HVR-950Q-MXL */
1865 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1866 DEVICE_FLG(0x2040, 0x7213, /* Hauppauge HVR-950Q */
1867 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1868 DEVICE_FLG(0x2040, 0x7217, /* Hauppauge HVR-950Q */
1869 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1870 DEVICE_FLG(0x2040, 0x721b, /* Hauppauge HVR-950Q */
1871 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1872 DEVICE_FLG(0x2040, 0x721e, /* Hauppauge HVR-950Q */
1873 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1874 DEVICE_FLG(0x2040, 0x721f, /* Hauppauge HVR-950Q */
1875 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1876 DEVICE_FLG(0x2040, 0x7240, /* Hauppauge HVR-850 */
1877 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1878 DEVICE_FLG(0x2040, 0x7260, /* Hauppauge HVR-950Q */
1879 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1880 DEVICE_FLG(0x2040, 0x7270, /* Hauppauge HVR-950Q */
1881 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1882 DEVICE_FLG(0x2040, 0x7280, /* Hauppauge HVR-950Q */
1883 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1884 DEVICE_FLG(0x2040, 0x7281, /* Hauppauge HVR-950Q-MXL */
1885 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1886 DEVICE_FLG(0x2040, 0x8200, /* Hauppauge Woodbury */
1887 QUIRK_FLAG_SHARE_MEDIA_DEVICE
| QUIRK_FLAG_ALIGN_TRANSFER
),
1888 DEVICE_FLG(0x21b4, 0x0081, /* AudioQuest DragonFly */
1889 QUIRK_FLAG_GET_SAMPLE_RATE
),
1890 DEVICE_FLG(0x2912, 0x30c8, /* Audioengine D1 */
1891 QUIRK_FLAG_GET_SAMPLE_RATE
),
1892 DEVICE_FLG(0x30be, 0x0101, /* Schiit Hel */
1893 QUIRK_FLAG_IGNORE_CTL_ERROR
),
1894 DEVICE_FLG(0x413c, 0xa506, /* Dell AE515 sound bar */
1895 QUIRK_FLAG_GET_SAMPLE_RATE
),
1896 DEVICE_FLG(0x534d, 0x2109, /* MacroSilicon MS2109 */
1897 QUIRK_FLAG_ALIGN_TRANSFER
),
1898 DEVICE_FLG(0x1224, 0x2a25, /* Jieli Technology USB PHY 2.0 */
1899 QUIRK_FLAG_GET_SAMPLE_RATE
),
1901 /* Vendor matches */
1902 VENDOR_FLG(0x045e, /* MS Lifecam */
1903 QUIRK_FLAG_GET_SAMPLE_RATE
),
1904 VENDOR_FLG(0x046d, /* Logitech */
1905 QUIRK_FLAG_CTL_MSG_DELAY_1M
),
1906 VENDOR_FLG(0x047f, /* Plantronics */
1907 QUIRK_FLAG_GET_SAMPLE_RATE
| QUIRK_FLAG_CTL_MSG_DELAY
),
1908 VENDOR_FLG(0x0644, /* TEAC Corp. */
1909 QUIRK_FLAG_CTL_MSG_DELAY
| QUIRK_FLAG_IFACE_DELAY
),
1910 VENDOR_FLG(0x07fd, /* MOTU */
1911 QUIRK_FLAG_VALIDATE_RATES
),
1912 VENDOR_FLG(0x1235, /* Focusrite Novation */
1913 QUIRK_FLAG_VALIDATE_RATES
),
1914 VENDOR_FLG(0x152a, /* Thesycon devices */
1915 QUIRK_FLAG_DSD_RAW
),
1916 VENDOR_FLG(0x1de7, /* Phoenix Audio */
1917 QUIRK_FLAG_GET_SAMPLE_RATE
),
1918 VENDOR_FLG(0x20b1, /* XMOS based devices */
1919 QUIRK_FLAG_DSD_RAW
),
1920 VENDOR_FLG(0x22d9, /* Oppo */
1921 QUIRK_FLAG_DSD_RAW
),
1922 VENDOR_FLG(0x23ba, /* Playback Design */
1923 QUIRK_FLAG_CTL_MSG_DELAY
| QUIRK_FLAG_IFACE_DELAY
|
1924 QUIRK_FLAG_DSD_RAW
),
1925 VENDOR_FLG(0x25ce, /* Mytek devices */
1926 QUIRK_FLAG_DSD_RAW
),
1927 VENDOR_FLG(0x278b, /* Rotel? */
1928 QUIRK_FLAG_DSD_RAW
),
1929 VENDOR_FLG(0x292b, /* Gustard/Ess based devices */
1930 QUIRK_FLAG_DSD_RAW
),
1931 VENDOR_FLG(0x2972, /* FiiO devices */
1932 QUIRK_FLAG_DSD_RAW
),
1933 VENDOR_FLG(0x2ab6, /* T+A devices */
1934 QUIRK_FLAG_DSD_RAW
),
1935 VENDOR_FLG(0x3353, /* Khadas devices */
1936 QUIRK_FLAG_DSD_RAW
),
1937 VENDOR_FLG(0x3842, /* EVGA */
1938 QUIRK_FLAG_DSD_RAW
),
1939 VENDOR_FLG(0xc502, /* HiBy devices */
1940 QUIRK_FLAG_DSD_RAW
),
1945 void snd_usb_init_quirk_flags(struct snd_usb_audio
*chip
)
1947 const struct usb_audio_quirk_flags_table
*p
;
1949 for (p
= quirk_flags_table
; p
->id
; p
++) {
1950 if (chip
->usb_id
== p
->id
||
1951 (!USB_ID_PRODUCT(p
->id
) &&
1952 USB_ID_VENDOR(chip
->usb_id
) == USB_ID_VENDOR(p
->id
))) {
1954 "Set quirk_flags 0x%x for device %04x:%04x\n",
1955 p
->flags
, USB_ID_VENDOR(chip
->usb_id
),
1956 USB_ID_PRODUCT(chip
->usb_id
));
1957 chip
->quirk_flags
|= p
->flags
;