2374 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 */4 5#include <linux/init.h>6#include <linux/slab.h>7#include <linux/usb.h>8#include <linux/usb/audio.h>9#include <linux/usb/midi.h>10#include <linux/bits.h>11 12#include <sound/control.h>13#include <sound/core.h>14#include <sound/info.h>15#include <sound/pcm.h>16 17#include "usbaudio.h"18#include "card.h"19#include "mixer.h"20#include "mixer_quirks.h"21#include "midi.h"22#include "midi2.h"23#include "quirks.h"24#include "helper.h"25#include "endpoint.h"26#include "pcm.h"27#include "clock.h"28#include "stream.h"29 30/*31 * handle the quirks for the contained interfaces32 */33static int create_composite_quirk(struct snd_usb_audio *chip,34 struct usb_interface *iface,35 struct usb_driver *driver,36 const struct snd_usb_audio_quirk *quirk_comp)37{38 int probed_ifnum = get_iface_desc(iface->altsetting)->bInterfaceNumber;39 const struct snd_usb_audio_quirk *quirk;40 int err;41 42 for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {43 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);44 if (!iface)45 continue;46 if (quirk->ifnum != probed_ifnum &&47 usb_interface_claimed(iface))48 continue;49 err = snd_usb_create_quirk(chip, iface, driver, quirk);50 if (err < 0)51 return err;52 }53 54 for (quirk = quirk_comp->data; quirk->ifnum >= 0; ++quirk) {55 iface = usb_ifnum_to_if(chip->dev, quirk->ifnum);56 if (!iface)57 continue;58 if (quirk->ifnum != probed_ifnum &&59 !usb_interface_claimed(iface)) {60 err = usb_driver_claim_interface(driver, iface,61 USB_AUDIO_IFACE_UNUSED);62 if (err < 0)63 return err;64 }65 }66 67 return 0;68}69 70static int ignore_interface_quirk(struct snd_usb_audio *chip,71 struct usb_interface *iface,72 struct usb_driver *driver,73 const struct snd_usb_audio_quirk *quirk)74{75 return 0;76}77 78 79static int create_any_midi_quirk(struct snd_usb_audio *chip,80 struct usb_interface *intf,81 struct usb_driver *driver,82 const struct snd_usb_audio_quirk *quirk)83{84 return snd_usb_midi_v2_create(chip, intf, quirk, 0);85}86 87/*88 * create a stream for an interface with proper descriptors89 */90static int create_standard_audio_quirk(struct snd_usb_audio *chip,91 struct usb_interface *iface,92 struct usb_driver *driver,93 const struct snd_usb_audio_quirk *quirk)94{95 struct usb_host_interface *alts;96 struct usb_interface_descriptor *altsd;97 int err;98 99 alts = &iface->altsetting[0];100 altsd = get_iface_desc(alts);101 err = snd_usb_parse_audio_interface(chip, altsd->bInterfaceNumber);102 if (err < 0) {103 usb_audio_err(chip, "cannot setup if %d: error %d\n",104 altsd->bInterfaceNumber, err);105 return err;106 }107 /* reset the current interface */108 usb_set_interface(chip->dev, altsd->bInterfaceNumber, 0);109 return 0;110}111 112/* create the audio stream and the corresponding endpoints from the fixed113 * audioformat object; this is used for quirks with the fixed EPs114 */115static int add_audio_stream_from_fixed_fmt(struct snd_usb_audio *chip,116 struct audioformat *fp)117{118 int stream, err;119 120 stream = (fp->endpoint & USB_DIR_IN) ?121 SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;122 123 snd_usb_audioformat_set_sync_ep(chip, fp);124 125 err = snd_usb_add_audio_stream(chip, stream, fp);126 if (err < 0)127 return err;128 129 err = snd_usb_add_endpoint(chip, fp->endpoint,130 SND_USB_ENDPOINT_TYPE_DATA);131 if (err < 0)132 return err;133 134 if (fp->sync_ep) {135 err = snd_usb_add_endpoint(chip, fp->sync_ep,136 fp->implicit_fb ?137 SND_USB_ENDPOINT_TYPE_DATA :138 SND_USB_ENDPOINT_TYPE_SYNC);139 if (err < 0)140 return err;141 }142 143 return 0;144}145 146/*147 * create a stream for an endpoint/altsetting without proper descriptors148 */149static int create_fixed_stream_quirk(struct snd_usb_audio *chip,150 struct usb_interface *iface,151 struct usb_driver *driver,152 const struct snd_usb_audio_quirk *quirk)153{154 struct audioformat *fp;155 struct usb_host_interface *alts;156 struct usb_interface_descriptor *altsd;157 unsigned *rate_table = NULL;158 int err;159 160 fp = kmemdup(quirk->data, sizeof(*fp), GFP_KERNEL);161 if (!fp)162 return -ENOMEM;163 164 INIT_LIST_HEAD(&fp->list);165 if (fp->nr_rates > MAX_NR_RATES) {166 kfree(fp);167 return -EINVAL;168 }169 if (fp->nr_rates > 0) {170 rate_table = kmemdup_array(fp->rate_table, fp->nr_rates, sizeof(int),171 GFP_KERNEL);172 if (!rate_table) {173 kfree(fp);174 return -ENOMEM;175 }176 fp->rate_table = rate_table;177 }178 179 if (fp->iface != get_iface_desc(&iface->altsetting[0])->bInterfaceNumber ||180 fp->altset_idx >= iface->num_altsetting) {181 err = -EINVAL;182 goto error;183 }184 alts = &iface->altsetting[fp->altset_idx];185 altsd = get_iface_desc(alts);186 if (altsd->bNumEndpoints <= fp->ep_idx) {187 err = -EINVAL;188 goto error;189 }190 191 fp->protocol = altsd->bInterfaceProtocol;192 193 if (fp->datainterval == 0)194 fp->datainterval = snd_usb_parse_datainterval(chip, alts);195 if (fp->maxpacksize == 0)196 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, fp->ep_idx)->wMaxPacketSize);197 if (!fp->fmt_type)198 fp->fmt_type = UAC_FORMAT_TYPE_I;199 200 err = add_audio_stream_from_fixed_fmt(chip, fp);201 if (err < 0)202 goto error;203 204 usb_set_interface(chip->dev, fp->iface, 0);205 snd_usb_init_pitch(chip, fp);206 snd_usb_init_sample_rate(chip, fp, fp->rate_max);207 return 0;208 209 error:210 list_del(&fp->list); /* unlink for avoiding double-free */211 kfree(fp);212 kfree(rate_table);213 return err;214}215 216static int create_auto_pcm_quirk(struct snd_usb_audio *chip,217 struct usb_interface *iface,218 struct usb_driver *driver)219{220 struct usb_host_interface *alts;221 struct usb_interface_descriptor *altsd;222 struct usb_endpoint_descriptor *epd;223 struct uac1_as_header_descriptor *ashd;224 struct uac_format_type_i_discrete_descriptor *fmtd;225 226 /*227 * Most Roland/Yamaha audio streaming interfaces have more or less228 * standard descriptors, but older devices might lack descriptors, and229 * future ones might change, so ensure that we fail silently if the230 * interface doesn't look exactly right.231 */232 233 /* must have a non-zero altsetting for streaming */234 if (iface->num_altsetting < 2)235 return -ENODEV;236 alts = &iface->altsetting[1];237 altsd = get_iface_desc(alts);238 239 /* must have an isochronous endpoint for streaming */240 if (altsd->bNumEndpoints < 1)241 return -ENODEV;242 epd = get_endpoint(alts, 0);243 if (!usb_endpoint_xfer_isoc(epd))244 return -ENODEV;245 246 /* must have format descriptors */247 ashd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,248 UAC_AS_GENERAL);249 fmtd = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL,250 UAC_FORMAT_TYPE);251 if (!ashd || ashd->bLength < 7 ||252 !fmtd || fmtd->bLength < 8)253 return -ENODEV;254 255 return create_standard_audio_quirk(chip, iface, driver, NULL);256}257 258static int create_yamaha_midi_quirk(struct snd_usb_audio *chip,259 struct usb_interface *iface,260 struct usb_driver *driver,261 struct usb_host_interface *alts)262{263 static const struct snd_usb_audio_quirk yamaha_midi_quirk = {264 .type = QUIRK_MIDI_YAMAHA265 };266 struct usb_midi_in_jack_descriptor *injd;267 struct usb_midi_out_jack_descriptor *outjd;268 269 /* must have some valid jack descriptors */270 injd = snd_usb_find_csint_desc(alts->extra, alts->extralen,271 NULL, USB_MS_MIDI_IN_JACK);272 outjd = snd_usb_find_csint_desc(alts->extra, alts->extralen,273 NULL, USB_MS_MIDI_OUT_JACK);274 if (!injd && !outjd)275 return -ENODEV;276 if ((injd && !snd_usb_validate_midi_desc(injd)) ||277 (outjd && !snd_usb_validate_midi_desc(outjd)))278 return -ENODEV;279 if (injd && (injd->bLength < 5 ||280 (injd->bJackType != USB_MS_EMBEDDED &&281 injd->bJackType != USB_MS_EXTERNAL)))282 return -ENODEV;283 if (outjd && (outjd->bLength < 6 ||284 (outjd->bJackType != USB_MS_EMBEDDED &&285 outjd->bJackType != USB_MS_EXTERNAL)))286 return -ENODEV;287 return create_any_midi_quirk(chip, iface, driver, &yamaha_midi_quirk);288}289 290static int create_roland_midi_quirk(struct snd_usb_audio *chip,291 struct usb_interface *iface,292 struct usb_driver *driver,293 struct usb_host_interface *alts)294{295 static const struct snd_usb_audio_quirk roland_midi_quirk = {296 .type = QUIRK_MIDI_ROLAND297 };298 u8 *roland_desc = NULL;299 300 /* might have a vendor-specific descriptor <06 24 F1 02 ...> */301 for (;;) {302 roland_desc = snd_usb_find_csint_desc(alts->extra,303 alts->extralen,304 roland_desc, 0xf1);305 if (!roland_desc)306 return -ENODEV;307 if (roland_desc[0] < 6 || roland_desc[3] != 2)308 continue;309 return create_any_midi_quirk(chip, iface, driver,310 &roland_midi_quirk);311 }312}313 314static int create_std_midi_quirk(struct snd_usb_audio *chip,315 struct usb_interface *iface,316 struct usb_driver *driver,317 struct usb_host_interface *alts)318{319 struct usb_ms_header_descriptor *mshd;320 struct usb_ms_endpoint_descriptor *msepd;321 322 /* must have the MIDIStreaming interface header descriptor*/323 mshd = (struct usb_ms_header_descriptor *)alts->extra;324 if (alts->extralen < 7 ||325 mshd->bLength < 7 ||326 mshd->bDescriptorType != USB_DT_CS_INTERFACE ||327 mshd->bDescriptorSubtype != USB_MS_HEADER)328 return -ENODEV;329 /* must have the MIDIStreaming endpoint descriptor*/330 msepd = (struct usb_ms_endpoint_descriptor *)alts->endpoint[0].extra;331 if (alts->endpoint[0].extralen < 4 ||332 msepd->bLength < 4 ||333 msepd->bDescriptorType != USB_DT_CS_ENDPOINT ||334 msepd->bDescriptorSubtype != UAC_MS_GENERAL ||335 msepd->bNumEmbMIDIJack < 1 ||336 msepd->bNumEmbMIDIJack > 16)337 return -ENODEV;338 339 return create_any_midi_quirk(chip, iface, driver, NULL);340}341 342static int create_auto_midi_quirk(struct snd_usb_audio *chip,343 struct usb_interface *iface,344 struct usb_driver *driver)345{346 struct usb_host_interface *alts;347 struct usb_interface_descriptor *altsd;348 struct usb_endpoint_descriptor *epd;349 int err;350 351 alts = &iface->altsetting[0];352 altsd = get_iface_desc(alts);353 354 /* must have at least one bulk/interrupt endpoint for streaming */355 if (altsd->bNumEndpoints < 1)356 return -ENODEV;357 epd = get_endpoint(alts, 0);358 if (!usb_endpoint_xfer_bulk(epd) &&359 !usb_endpoint_xfer_int(epd))360 return -ENODEV;361 362 switch (USB_ID_VENDOR(chip->usb_id)) {363 case 0x0499: /* Yamaha */364 err = create_yamaha_midi_quirk(chip, iface, driver, alts);365 if (err != -ENODEV)366 return err;367 break;368 case 0x0582: /* Roland */369 err = create_roland_midi_quirk(chip, iface, driver, alts);370 if (err != -ENODEV)371 return err;372 break;373 }374 375 return create_std_midi_quirk(chip, iface, driver, alts);376}377 378static int create_autodetect_quirk(struct snd_usb_audio *chip,379 struct usb_interface *iface,380 struct usb_driver *driver,381 const struct snd_usb_audio_quirk *quirk)382{383 int err;384 385 err = create_auto_pcm_quirk(chip, iface, driver);386 if (err == -ENODEV)387 err = create_auto_midi_quirk(chip, iface, driver);388 return err;389}390 391/*392 * Create a stream for an Edirol UA-700/UA-25/UA-4FX interface. 393 * The only way to detect the sample rate is by looking at wMaxPacketSize.394 */395static int create_uaxx_quirk(struct snd_usb_audio *chip,396 struct usb_interface *iface,397 struct usb_driver *driver,398 const struct snd_usb_audio_quirk *quirk)399{400 static const struct audioformat ua_format = {401 .formats = SNDRV_PCM_FMTBIT_S24_3LE,402 .channels = 2,403 .fmt_type = UAC_FORMAT_TYPE_I,404 .altsetting = 1,405 .altset_idx = 1,406 .rates = SNDRV_PCM_RATE_CONTINUOUS,407 };408 struct usb_host_interface *alts;409 struct usb_interface_descriptor *altsd;410 struct audioformat *fp;411 int err;412 413 /* both PCM and MIDI interfaces have 2 or more altsettings */414 if (iface->num_altsetting < 2)415 return -ENXIO;416 alts = &iface->altsetting[1];417 altsd = get_iface_desc(alts);418 419 if (altsd->bNumEndpoints == 2) {420 static const struct snd_usb_midi_endpoint_info ua700_ep = {421 .out_cables = 0x0003,422 .in_cables = 0x0003423 };424 static const struct snd_usb_audio_quirk ua700_quirk = {425 .type = QUIRK_MIDI_FIXED_ENDPOINT,426 .data = &ua700_ep427 };428 static const struct snd_usb_midi_endpoint_info uaxx_ep = {429 .out_cables = 0x0001,430 .in_cables = 0x0001431 };432 static const struct snd_usb_audio_quirk uaxx_quirk = {433 .type = QUIRK_MIDI_FIXED_ENDPOINT,434 .data = &uaxx_ep435 };436 const struct snd_usb_audio_quirk *quirk =437 chip->usb_id == USB_ID(0x0582, 0x002b)438 ? &ua700_quirk : &uaxx_quirk;439 return __snd_usbmidi_create(chip->card, iface,440 &chip->midi_list, quirk,441 chip->usb_id,442 &chip->num_rawmidis);443 }444 445 if (altsd->bNumEndpoints != 1)446 return -ENXIO;447 448 fp = kmemdup(&ua_format, sizeof(*fp), GFP_KERNEL);449 if (!fp)450 return -ENOMEM;451 452 fp->iface = altsd->bInterfaceNumber;453 fp->endpoint = get_endpoint(alts, 0)->bEndpointAddress;454 fp->ep_attr = get_endpoint(alts, 0)->bmAttributes;455 fp->datainterval = 0;456 fp->maxpacksize = le16_to_cpu(get_endpoint(alts, 0)->wMaxPacketSize);457 INIT_LIST_HEAD(&fp->list);458 459 switch (fp->maxpacksize) {460 case 0x120:461 fp->rate_max = fp->rate_min = 44100;462 break;463 case 0x138:464 case 0x140:465 fp->rate_max = fp->rate_min = 48000;466 break;467 case 0x258:468 case 0x260:469 fp->rate_max = fp->rate_min = 96000;470 break;471 default:472 usb_audio_err(chip, "unknown sample rate\n");473 kfree(fp);474 return -ENXIO;475 }476 477 err = add_audio_stream_from_fixed_fmt(chip, fp);478 if (err < 0) {479 list_del(&fp->list); /* unlink for avoiding double-free */480 kfree(fp);481 return err;482 }483 usb_set_interface(chip->dev, fp->iface, 0);484 return 0;485}486 487/*488 * Create a standard mixer for the specified interface.489 */490static int create_standard_mixer_quirk(struct snd_usb_audio *chip,491 struct usb_interface *iface,492 struct usb_driver *driver,493 const struct snd_usb_audio_quirk *quirk)494{495 if (quirk->ifnum < 0)496 return 0;497 498 return snd_usb_create_mixer(chip, quirk->ifnum);499}500 501/*502 * audio-interface quirks503 *504 * returns zero if no standard audio/MIDI parsing is needed.505 * returns a positive value if standard audio/midi interfaces are parsed506 * after this.507 * returns a negative value at error.508 */509int snd_usb_create_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 typedef int (*quirk_func_t)(struct snd_usb_audio *,515 struct usb_interface *,516 struct usb_driver *,517 const struct snd_usb_audio_quirk *);518 static const quirk_func_t quirk_funcs[] = {519 [QUIRK_IGNORE_INTERFACE] = ignore_interface_quirk,520 [QUIRK_COMPOSITE] = create_composite_quirk,521 [QUIRK_AUTODETECT] = create_autodetect_quirk,522 [QUIRK_MIDI_STANDARD_INTERFACE] = create_any_midi_quirk,523 [QUIRK_MIDI_FIXED_ENDPOINT] = create_any_midi_quirk,524 [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk,525 [QUIRK_MIDI_ROLAND] = create_any_midi_quirk,526 [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk,527 [QUIRK_MIDI_NOVATION] = create_any_midi_quirk,528 [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk,529 [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk,530 [QUIRK_MIDI_CME] = create_any_midi_quirk,531 [QUIRK_MIDI_AKAI] = create_any_midi_quirk,532 [QUIRK_MIDI_FTDI] = create_any_midi_quirk,533 [QUIRK_MIDI_CH345] = create_any_midi_quirk,534 [QUIRK_AUDIO_STANDARD_INTERFACE] = create_standard_audio_quirk,535 [QUIRK_AUDIO_FIXED_ENDPOINT] = create_fixed_stream_quirk,536 [QUIRK_AUDIO_EDIROL_UAXX] = create_uaxx_quirk,537 [QUIRK_AUDIO_STANDARD_MIXER] = create_standard_mixer_quirk,538 };539 540 if (quirk->type < QUIRK_TYPE_COUNT) {541 return quirk_funcs[quirk->type](chip, iface, driver, quirk);542 } else {543 usb_audio_err(chip, "invalid quirk type %d\n", quirk->type);544 return -ENXIO;545 }546}547 548/*549 * boot quirks550 */551 552#define EXTIGY_FIRMWARE_SIZE_OLD 794553#define EXTIGY_FIRMWARE_SIZE_NEW 483554 555static int snd_usb_extigy_boot_quirk(struct usb_device *dev, struct usb_interface *intf)556{557 struct usb_host_config *config = dev->actconfig;558 int err;559 560 if (le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_OLD ||561 le16_to_cpu(get_cfg_desc(config)->wTotalLength) == EXTIGY_FIRMWARE_SIZE_NEW) {562 dev_dbg(&dev->dev, "sending Extigy boot sequence...\n");563 /* Send message to force it to reconnect with full interface. */564 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev,0),565 0x10, 0x43, 0x0001, 0x000a, NULL, 0);566 if (err < 0)567 dev_dbg(&dev->dev, "error sending boot message: %d\n", err);568 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,569 &dev->descriptor, sizeof(dev->descriptor));570 config = dev->actconfig;571 if (err < 0)572 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);573 err = usb_reset_configuration(dev);574 if (err < 0)575 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);576 dev_dbg(&dev->dev, "extigy_boot: new boot length = %d\n",577 le16_to_cpu(get_cfg_desc(config)->wTotalLength));578 return -ENODEV; /* quit this anyway */579 }580 return 0;581}582 583static int snd_usb_audigy2nx_boot_quirk(struct usb_device *dev)584{585 u8 buf = 1;586 587 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), 0x2a,588 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER,589 0, 0, &buf, 1);590 if (buf == 0) {591 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0x29,592 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER,593 1, 2000, NULL, 0);594 return -ENODEV;595 }596 return 0;597}598 599static int snd_usb_fasttrackpro_boot_quirk(struct usb_device *dev)600{601 int err;602 603 if (dev->actconfig->desc.bConfigurationValue == 1) {604 dev_info(&dev->dev,605 "Fast Track Pro switching to config #2\n");606 /* This function has to be available by the usb core module.607 * if it is not avialable the boot quirk has to be left out608 * and the configuration has to be set by udev or hotplug609 * rules610 */611 err = usb_driver_set_configuration(dev, 2);612 if (err < 0)613 dev_dbg(&dev->dev,614 "error usb_driver_set_configuration: %d\n",615 err);616 /* Always return an error, so that we stop creating a device617 that will just be destroyed and recreated with a new618 configuration */619 return -ENODEV;620 } else621 dev_info(&dev->dev, "Fast Track Pro config OK\n");622 623 return 0;624}625 626/*627 * C-Media CM106/CM106+ have four 16-bit internal registers that are nicely628 * documented in the device's data sheet.629 */630static int snd_usb_cm106_write_int_reg(struct usb_device *dev, int reg, u16 value)631{632 u8 buf[4];633 buf[0] = 0x20;634 buf[1] = value & 0xff;635 buf[2] = (value >> 8) & 0xff;636 buf[3] = reg;637 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), USB_REQ_SET_CONFIGURATION,638 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,639 0, 0, &buf, 4);640}641 642static int snd_usb_cm106_boot_quirk(struct usb_device *dev)643{644 /*645 * Enable line-out driver mode, set headphone source to front646 * channels, enable stereo mic.647 */648 return snd_usb_cm106_write_int_reg(dev, 2, 0x8004);649}650 651/*652 * CM6206 registers from the CM6206 datasheet rev 2.1653 */654#define CM6206_REG0_DMA_MASTER BIT(15)655#define CM6206_REG0_SPDIFO_RATE_48K (2 << 12)656#define CM6206_REG0_SPDIFO_RATE_96K (7 << 12)657/* Bit 4 thru 11 is the S/PDIF category code */658#define CM6206_REG0_SPDIFO_CAT_CODE_GENERAL (0 << 4)659#define CM6206_REG0_SPDIFO_EMPHASIS_CD BIT(3)660#define CM6206_REG0_SPDIFO_COPYRIGHT_NA BIT(2)661#define CM6206_REG0_SPDIFO_NON_AUDIO BIT(1)662#define CM6206_REG0_SPDIFO_PRO_FORMAT BIT(0)663 664#define CM6206_REG1_TEST_SEL_CLK BIT(14)665#define CM6206_REG1_PLLBIN_EN BIT(13)666#define CM6206_REG1_SOFT_MUTE_EN BIT(12)667#define CM6206_REG1_GPIO4_OUT BIT(11)668#define CM6206_REG1_GPIO4_OE BIT(10)669#define CM6206_REG1_GPIO3_OUT BIT(9)670#define CM6206_REG1_GPIO3_OE BIT(8)671#define CM6206_REG1_GPIO2_OUT BIT(7)672#define CM6206_REG1_GPIO2_OE BIT(6)673#define CM6206_REG1_GPIO1_OUT BIT(5)674#define CM6206_REG1_GPIO1_OE BIT(4)675#define CM6206_REG1_SPDIFO_INVALID BIT(3)676#define CM6206_REG1_SPDIF_LOOP_EN BIT(2)677#define CM6206_REG1_SPDIFO_DIS BIT(1)678#define CM6206_REG1_SPDIFI_MIX BIT(0)679 680#define CM6206_REG2_DRIVER_ON BIT(15)681#define CM6206_REG2_HEADP_SEL_SIDE_CHANNELS (0 << 13)682#define CM6206_REG2_HEADP_SEL_SURROUND_CHANNELS (1 << 13)683#define CM6206_REG2_HEADP_SEL_CENTER_SUBW (2 << 13)684#define CM6206_REG2_HEADP_SEL_FRONT_CHANNELS (3 << 13)685#define CM6206_REG2_MUTE_HEADPHONE_RIGHT BIT(12)686#define CM6206_REG2_MUTE_HEADPHONE_LEFT BIT(11)687#define CM6206_REG2_MUTE_REAR_SURROUND_RIGHT BIT(10)688#define CM6206_REG2_MUTE_REAR_SURROUND_LEFT BIT(9)689#define CM6206_REG2_MUTE_SIDE_SURROUND_RIGHT BIT(8)690#define CM6206_REG2_MUTE_SIDE_SURROUND_LEFT BIT(7)691#define CM6206_REG2_MUTE_SUBWOOFER BIT(6)692#define CM6206_REG2_MUTE_CENTER BIT(5)693#define CM6206_REG2_MUTE_RIGHT_FRONT BIT(3)694#define CM6206_REG2_MUTE_LEFT_FRONT BIT(3)695#define CM6206_REG2_EN_BTL BIT(2)696#define CM6206_REG2_MCUCLKSEL_1_5_MHZ (0)697#define CM6206_REG2_MCUCLKSEL_3_MHZ (1)698#define CM6206_REG2_MCUCLKSEL_6_MHZ (2)699#define CM6206_REG2_MCUCLKSEL_12_MHZ (3)700 701/* Bit 11..13 sets the sensitivity to FLY tuner volume control VP/VD signal */702#define CM6206_REG3_FLYSPEED_DEFAULT (2 << 11)703#define CM6206_REG3_VRAP25EN BIT(10)704#define CM6206_REG3_MSEL1 BIT(9)705#define CM6206_REG3_SPDIFI_RATE_44_1K BIT(0 << 7)706#define CM6206_REG3_SPDIFI_RATE_48K BIT(2 << 7)707#define CM6206_REG3_SPDIFI_RATE_32K BIT(3 << 7)708#define CM6206_REG3_PINSEL BIT(6)709#define CM6206_REG3_FOE BIT(5)710#define CM6206_REG3_ROE BIT(4)711#define CM6206_REG3_CBOE BIT(3)712#define CM6206_REG3_LOSE BIT(2)713#define CM6206_REG3_HPOE BIT(1)714#define CM6206_REG3_SPDIFI_CANREC BIT(0)715 716#define CM6206_REG5_DA_RSTN BIT(13)717#define CM6206_REG5_AD_RSTN BIT(12)718#define CM6206_REG5_SPDIFO_AD2SPDO BIT(12)719#define CM6206_REG5_SPDIFO_SEL_FRONT (0 << 9)720#define CM6206_REG5_SPDIFO_SEL_SIDE_SUR (1 << 9)721#define CM6206_REG5_SPDIFO_SEL_CEN_LFE (2 << 9)722#define CM6206_REG5_SPDIFO_SEL_REAR_SUR (3 << 9)723#define CM6206_REG5_CODECM BIT(8)724#define CM6206_REG5_EN_HPF BIT(7)725#define CM6206_REG5_T_SEL_DSDA4 BIT(6)726#define CM6206_REG5_T_SEL_DSDA3 BIT(5)727#define CM6206_REG5_T_SEL_DSDA2 BIT(4)728#define CM6206_REG5_T_SEL_DSDA1 BIT(3)729#define CM6206_REG5_T_SEL_DSDAD_NORMAL 0730#define CM6206_REG5_T_SEL_DSDAD_FRONT 4731#define CM6206_REG5_T_SEL_DSDAD_S_SURROUND 5732#define CM6206_REG5_T_SEL_DSDAD_CEN_LFE 6733#define CM6206_REG5_T_SEL_DSDAD_R_SURROUND 7734 735static int snd_usb_cm6206_boot_quirk(struct usb_device *dev)736{737 int err = 0, reg;738 int val[] = {739 /*740 * Values here are chosen based on sniffing USB traffic741 * under Windows.742 *743 * REG0: DAC is master, sample rate 48kHz, no copyright744 */745 CM6206_REG0_SPDIFO_RATE_48K |746 CM6206_REG0_SPDIFO_COPYRIGHT_NA,747 /*748 * REG1: PLL binary search enable, soft mute enable.749 */750 CM6206_REG1_PLLBIN_EN |751 CM6206_REG1_SOFT_MUTE_EN,752 /*753 * REG2: enable output drivers,754 * select front channels to the headphone output,755 * then mute the headphone channels, run the MCU756 * at 1.5 MHz.757 */758 CM6206_REG2_DRIVER_ON |759 CM6206_REG2_HEADP_SEL_FRONT_CHANNELS |760 CM6206_REG2_MUTE_HEADPHONE_RIGHT |761 CM6206_REG2_MUTE_HEADPHONE_LEFT,762 /*763 * REG3: default flyspeed, set 2.5V mic bias764 * enable all line out ports and enable SPDIF765 */766 CM6206_REG3_FLYSPEED_DEFAULT |767 CM6206_REG3_VRAP25EN |768 CM6206_REG3_FOE |769 CM6206_REG3_ROE |770 CM6206_REG3_CBOE |771 CM6206_REG3_LOSE |772 CM6206_REG3_HPOE |773 CM6206_REG3_SPDIFI_CANREC,774 /* REG4 is just a bunch of GPIO lines */775 0x0000,776 /* REG5: de-assert AD/DA reset signals */777 CM6206_REG5_DA_RSTN |778 CM6206_REG5_AD_RSTN };779 780 for (reg = 0; reg < ARRAY_SIZE(val); reg++) {781 err = snd_usb_cm106_write_int_reg(dev, reg, val[reg]);782 if (err < 0)783 return err;784 }785 786 return err;787}788 789/* quirk for Plantronics GameCom 780 with CM6302 chip */790static int snd_usb_gamecon780_boot_quirk(struct usb_device *dev)791{792 /* set the initial volume and don't change; other values are either793 * too loud or silent due to firmware bug (bko#65251)794 */795 u8 buf[2] = { 0x74, 0xe3 };796 return snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,797 USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT,798 UAC_FU_VOLUME << 8, 9 << 8, buf, 2);799}800 801/*802 * Novation Twitch DJ controller803 * Focusrite Novation Saffire 6 USB audio card804 */805static int snd_usb_novation_boot_quirk(struct usb_device *dev)806{807 /* preemptively set up the device because otherwise the808 * raw MIDI endpoints are not active */809 usb_set_interface(dev, 0, 1);810 return 0;811}812 813/*814 * This call will put the synth in "USB send" mode, i.e it will send MIDI815 * messages through USB (this is disabled at startup). The synth will816 * acknowledge by sending a sysex on endpoint 0x85 and by displaying a USB817 * sign on its LCD. Values here are chosen based on sniffing USB traffic818 * under Windows.819 */820static int snd_usb_accessmusic_boot_quirk(struct usb_device *dev)821{822 int err, actual_length;823 /* "midi send" enable */824 static const u8 seq[] = { 0x4e, 0x73, 0x52, 0x01 };825 void *buf;826 827 if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x05)))828 return -EINVAL;829 buf = kmemdup(seq, ARRAY_SIZE(seq), GFP_KERNEL);830 if (!buf)831 return -ENOMEM;832 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x05), buf,833 ARRAY_SIZE(seq), &actual_length, 1000);834 kfree(buf);835 if (err < 0)836 return err;837 838 return 0;839}840 841/*842 * Some sound cards from Native Instruments are in fact compliant to the USB843 * audio standard of version 2 and other approved USB standards, even though844 * they come up as vendor-specific device when first connected.845 *846 * However, they can be told to come up with a new set of descriptors847 * upon their next enumeration, and the interfaces announced by the new848 * descriptors will then be handled by the kernel's class drivers. As the849 * product ID will also change, no further checks are required.850 */851 852static int snd_usb_nativeinstruments_boot_quirk(struct usb_device *dev)853{854 int ret;855 856 ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),857 0xaf, USB_TYPE_VENDOR | USB_RECIP_DEVICE,858 1, 0, NULL, 0, 1000);859 860 if (ret < 0)861 return ret;862 863 usb_reset_device(dev);864 865 /* return -EAGAIN, so the creation of an audio interface for this866 * temporary device is aborted. The device will reconnect with a867 * new product ID */868 return -EAGAIN;869}870 871static void mbox2_setup_48_24_magic(struct usb_device *dev)872{873 u8 srate[3];874 u8 temp[12];875 876 /* Choose 48000Hz permanently */877 srate[0] = 0x80;878 srate[1] = 0xbb;879 srate[2] = 0x00;880 881 /* Send the magic! */882 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),883 0x01, 0x22, 0x0100, 0x0085, &temp, 0x0003);884 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),885 0x81, 0xa2, 0x0100, 0x0085, &srate, 0x0003);886 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),887 0x81, 0xa2, 0x0100, 0x0086, &srate, 0x0003);888 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),889 0x81, 0xa2, 0x0100, 0x0003, &srate, 0x0003);890 return;891}892 893/* Digidesign Mbox 2 needs to load firmware onboard894 * and driver must wait a few seconds for initialisation.895 */896 897#define MBOX2_FIRMWARE_SIZE 646898#define MBOX2_BOOT_LOADING 0x01 /* Hard coded into the device */899#define MBOX2_BOOT_READY 0x02 /* Hard coded into the device */900 901static int snd_usb_mbox2_boot_quirk(struct usb_device *dev)902{903 struct usb_host_config *config = dev->actconfig;904 int err;905 u8 bootresponse[0x12];906 int fwsize;907 int count;908 909 fwsize = le16_to_cpu(get_cfg_desc(config)->wTotalLength);910 911 if (fwsize != MBOX2_FIRMWARE_SIZE) {912 dev_err(&dev->dev, "Invalid firmware size=%d.\n", fwsize);913 return -ENODEV;914 }915 916 dev_dbg(&dev->dev, "Sending Digidesign Mbox 2 boot sequence...\n");917 918 count = 0;919 bootresponse[0] = MBOX2_BOOT_LOADING;920 while ((bootresponse[0] == MBOX2_BOOT_LOADING) && (count < 10)) {921 msleep(500); /* 0.5 second delay */922 snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0),923 /* Control magic - load onboard firmware */924 0x85, 0xc0, 0x0001, 0x0000, &bootresponse, 0x0012);925 if (bootresponse[0] == MBOX2_BOOT_READY)926 break;927 dev_dbg(&dev->dev, "device not ready, resending boot sequence...\n");928 count++;929 }930 931 if (bootresponse[0] != MBOX2_BOOT_READY) {932 dev_err(&dev->dev, "Unknown bootresponse=%d, or timed out, ignoring device.\n", bootresponse[0]);933 return -ENODEV;934 }935 936 dev_dbg(&dev->dev, "device initialised!\n");937 938 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,939 &dev->descriptor, sizeof(dev->descriptor));940 config = dev->actconfig;941 if (err < 0)942 dev_dbg(&dev->dev, "error usb_get_descriptor: %d\n", err);943 944 err = usb_reset_configuration(dev);945 if (err < 0)946 dev_dbg(&dev->dev, "error usb_reset_configuration: %d\n", err);947 dev_dbg(&dev->dev, "mbox2_boot: new boot length = %d\n",948 le16_to_cpu(get_cfg_desc(config)->wTotalLength));949 950 mbox2_setup_48_24_magic(dev);951 952 dev_info(&dev->dev, "Digidesign Mbox 2: 24bit 48kHz");953 954 return 0; /* Successful boot */955}956 957static int snd_usb_axefx3_boot_quirk(struct usb_device *dev)958{959 int err;960 961 dev_dbg(&dev->dev, "Waiting for Axe-Fx III to boot up...\n");962 963 /* If the Axe-Fx III has not fully booted, it will timeout when trying964 * to enable the audio streaming interface. A more generous timeout is965 * used here to detect when the Axe-Fx III has finished booting as the966 * set interface message will be acked once it has967 */968 err = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),969 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE,970 1, 1, NULL, 0, 120000);971 if (err < 0) {972 dev_err(&dev->dev,973 "failed waiting for Axe-Fx III to boot: %d\n", err);974 return err;975 }976 977 dev_dbg(&dev->dev, "Axe-Fx III is now ready\n");978 979 err = usb_set_interface(dev, 1, 0);980 if (err < 0)981 dev_dbg(&dev->dev,982 "error stopping Axe-Fx III interface: %d\n", err);983 984 return 0;985}986 987static void mbox3_setup_defaults(struct usb_device *dev)988{989 /* The Mbox 3 is "little endian" */990 /* max volume is: 0x0000. */991 /* min volume is: 0x0080 (shown in little endian form) */992 993 u8 com_buff[2];994 995 /* Deactivate Tuner */996 /* on = 0x01*/997 /* off = 0x00*/998 com_buff[0] = 0x00;999 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1000 0x01, 0x21, 0x0003, 0x2001, &com_buff, 1);1001 1002 /* Set clock source to Internal (as opposed to S/PDIF) */1003 /* Internal = 0x01*/1004 /* S/PDIF = 0x02*/1005 com_buff[0] = 0x01;1006 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1007 1, 0x21, 0x0100, 0x8001, &com_buff, 1);1008 1009 /* Mute the hardware loopbacks to start the device in a known state. */1010 com_buff[0] = 0x00;1011 com_buff[1] = 0x80;1012 /* Analogue input 1 left channel: */1013 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1014 1, 0x21, 0x0110, 0x4001, &com_buff, 2);1015 /* Analogue input 1 right channel: */1016 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1017 1, 0x21, 0x0111, 0x4001, &com_buff, 2);1018 /* Analogue input 2 left channel: */1019 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1020 1, 0x21, 0x0114, 0x4001, &com_buff, 2);1021 /* Analogue input 2 right channel: */1022 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1023 1, 0x21, 0x0115, 0x4001, &com_buff, 2);1024 /* Analogue input 3 left channel: */1025 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1026 1, 0x21, 0x0118, 0x4001, &com_buff, 2);1027 /* Analogue input 3 right channel: */1028 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1029 1, 0x21, 0x0119, 0x4001, &com_buff, 2);1030 /* Analogue input 4 left channel: */1031 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1032 1, 0x21, 0x011c, 0x4001, &com_buff, 2);1033 /* Analogue input 4 right channel: */1034 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1035 1, 0x21, 0x011d, 0x4001, &com_buff, 2);1036 1037 /* Set software sends to output */1038 com_buff[0] = 0x00;1039 com_buff[1] = 0x00;1040 /* Analogue software return 1 left channel: */1041 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1042 1, 0x21, 0x0100, 0x4001, &com_buff, 2);1043 com_buff[0] = 0x00;1044 com_buff[1] = 0x80;1045 /* Analogue software return 1 right channel: */1046 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1047 1, 0x21, 0x0101, 0x4001, &com_buff, 2);1048 com_buff[0] = 0x00;1049 com_buff[1] = 0x80;1050 /* Analogue software return 2 left channel: */1051 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1052 1, 0x21, 0x0104, 0x4001, &com_buff, 2);1053 com_buff[0] = 0x00;1054 com_buff[1] = 0x00;1055 /* Analogue software return 2 right channel: */1056 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1057 1, 0x21, 0x0105, 0x4001, &com_buff, 2);1058 1059 com_buff[0] = 0x00;1060 com_buff[1] = 0x80;1061 /* Analogue software return 3 left channel: */1062 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1063 1, 0x21, 0x0108, 0x4001, &com_buff, 2);1064 /* Analogue software return 3 right channel: */1065 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1066 1, 0x21, 0x0109, 0x4001, &com_buff, 2);1067 /* Analogue software return 4 left channel: */1068 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1069 1, 0x21, 0x010c, 0x4001, &com_buff, 2);1070 /* Analogue software return 4 right channel: */1071 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1072 1, 0x21, 0x010d, 0x4001, &com_buff, 2);1073 1074 /* Return to muting sends */1075 com_buff[0] = 0x00;1076 com_buff[1] = 0x80;1077 /* Analogue fx return left channel: */1078 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1079 1, 0x21, 0x0120, 0x4001, &com_buff, 2);1080 /* Analogue fx return right channel: */1081 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1082 1, 0x21, 0x0121, 0x4001, &com_buff, 2);1083 1084 /* Analogue software input 1 fx send: */1085 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1086 1, 0x21, 0x0100, 0x4201, &com_buff, 2);1087 /* Analogue software input 2 fx send: */1088 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1089 1, 0x21, 0x0101, 0x4201, &com_buff, 2);1090 /* Analogue software input 3 fx send: */1091 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1092 1, 0x21, 0x0102, 0x4201, &com_buff, 2);1093 /* Analogue software input 4 fx send: */1094 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1095 1, 0x21, 0x0103, 0x4201, &com_buff, 2);1096 /* Analogue input 1 fx send: */1097 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1098 1, 0x21, 0x0104, 0x4201, &com_buff, 2);1099 /* Analogue input 2 fx send: */1100 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1101 1, 0x21, 0x0105, 0x4201, &com_buff, 2);1102 /* Analogue input 3 fx send: */1103 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1104 1, 0x21, 0x0106, 0x4201, &com_buff, 2);1105 /* Analogue input 4 fx send: */1106 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1107 1, 0x21, 0x0107, 0x4201, &com_buff, 2);1108 1109 /* Toggle allowing host control */1110 /* Not needed1111 com_buff[0] = 0x02;1112 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1113 3, 0x21, 0x0000, 0x2001, &com_buff, 1);1114 */1115 1116 /* Do not dim fx returns */1117 com_buff[0] = 0x00;1118 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1119 3, 0x21, 0x0002, 0x2001, &com_buff, 1);1120 1121 /* Do not set fx returns to mono */1122 com_buff[0] = 0x00;1123 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1124 3, 0x21, 0x0001, 0x2001, &com_buff, 1);1125 1126 /* Mute the S/PDIF hardware loopback1127 * same odd volume logic here as above1128 */1129 com_buff[0] = 0x00;1130 com_buff[1] = 0x80;1131 /* S/PDIF hardware input 1 left channel */1132 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1133 1, 0x21, 0x0112, 0x4001, &com_buff, 2);1134 /* S/PDIF hardware input 1 right channel */1135 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1136 1, 0x21, 0x0113, 0x4001, &com_buff, 2);1137 /* S/PDIF hardware input 2 left channel */1138 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1139 1, 0x21, 0x0116, 0x4001, &com_buff, 2);1140 /* S/PDIF hardware input 2 right channel */1141 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1142 1, 0x21, 0x0117, 0x4001, &com_buff, 2);1143 /* S/PDIF hardware input 3 left channel */1144 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1145 1, 0x21, 0x011a, 0x4001, &com_buff, 2);1146 /* S/PDIF hardware input 3 right channel */1147 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1148 1, 0x21, 0x011b, 0x4001, &com_buff, 2);1149 /* S/PDIF hardware input 4 left channel */1150 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1151 1, 0x21, 0x011e, 0x4001, &com_buff, 2);1152 /* S/PDIF hardware input 4 right channel */1153 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1154 1, 0x21, 0x011f, 0x4001, &com_buff, 2);1155 /* S/PDIF software return 1 left channel */1156 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1157 1, 0x21, 0x0102, 0x4001, &com_buff, 2);1158 /* S/PDIF software return 1 right channel */1159 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1160 1, 0x21, 0x0103, 0x4001, &com_buff, 2);1161 /* S/PDIF software return 2 left channel */1162 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1163 1, 0x21, 0x0106, 0x4001, &com_buff, 2);1164 /* S/PDIF software return 2 right channel */1165 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1166 1, 0x21, 0x0107, 0x4001, &com_buff, 2);1167 1168 com_buff[0] = 0x00;1169 com_buff[1] = 0x00;1170 /* S/PDIF software return 3 left channel */1171 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1172 1, 0x21, 0x010a, 0x4001, &com_buff, 2);1173 1174 com_buff[0] = 0x00;1175 com_buff[1] = 0x80;1176 /* S/PDIF software return 3 right channel */1177 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1178 1, 0x21, 0x010b, 0x4001, &com_buff, 2);1179 /* S/PDIF software return 4 left channel */1180 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1181 1, 0x21, 0x010e, 0x4001, &com_buff, 2);1182 1183 com_buff[0] = 0x00;1184 com_buff[1] = 0x00;1185 /* S/PDIF software return 4 right channel */1186 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1187 1, 0x21, 0x010f, 0x4001, &com_buff, 2);1188 1189 com_buff[0] = 0x00;1190 com_buff[1] = 0x80;1191 /* S/PDIF fx returns left channel */1192 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1193 1, 0x21, 0x0122, 0x4001, &com_buff, 2);1194 /* S/PDIF fx returns right channel */1195 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1196 1, 0x21, 0x0123, 0x4001, &com_buff, 2);1197 1198 /* Set the dropdown "Effect" to the first option */1199 /* Room1 = 0x00 */1200 /* Room2 = 0x01 */1201 /* Room3 = 0x02 */1202 /* Hall 1 = 0x03 */1203 /* Hall 2 = 0x04 */1204 /* Plate = 0x05 */1205 /* Delay = 0x06 */1206 /* Echo = 0x07 */1207 com_buff[0] = 0x00;1208 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1209 1, 0x21, 0x0200, 0x4301, &com_buff, 1); /* max is 0xff */1210 /* min is 0x00 */1211 1212 1213 /* Set the effect duration to 0 */1214 /* max is 0xffff */1215 /* min is 0x0000 */1216 com_buff[0] = 0x00;1217 com_buff[1] = 0x00;1218 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1219 1, 0x21, 0x0400, 0x4301, &com_buff, 2);1220 1221 /* Set the effect volume and feedback to 0 */1222 /* max is 0xff */1223 /* min is 0x00 */1224 com_buff[0] = 0x00;1225 /* feedback: */1226 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1227 1, 0x21, 0x0500, 0x4301, &com_buff, 1);1228 /* volume: */1229 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1230 1, 0x21, 0x0300, 0x4301, &com_buff, 1);1231 1232 /* Set soft button hold duration */1233 /* 0x03 = 250ms */1234 /* 0x05 = 500ms DEFAULT */1235 /* 0x08 = 750ms */1236 /* 0x0a = 1sec */1237 com_buff[0] = 0x05;1238 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1239 3, 0x21, 0x0005, 0x2001, &com_buff, 1);1240 1241 /* Use dim LEDs for button of state */1242 com_buff[0] = 0x00;1243 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1244 3, 0x21, 0x0004, 0x2001, &com_buff, 1);1245}1246 1247#define MBOX3_DESCRIPTOR_SIZE 4641248 1249static int snd_usb_mbox3_boot_quirk(struct usb_device *dev)1250{1251 struct usb_host_config *config = dev->actconfig;1252 int err;1253 int descriptor_size;1254 1255 descriptor_size = le16_to_cpu(get_cfg_desc(config)->wTotalLength);1256 1257 if (descriptor_size != MBOX3_DESCRIPTOR_SIZE) {1258 dev_err(&dev->dev, "MBOX3: Invalid descriptor size=%d.\n", descriptor_size);1259 return -ENODEV;1260 }1261 1262 dev_dbg(&dev->dev, "MBOX3: device initialised!\n");1263 1264 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0,1265 &dev->descriptor, sizeof(dev->descriptor));1266 config = dev->actconfig;1267 if (err < 0)1268 dev_dbg(&dev->dev, "MBOX3: error usb_get_descriptor: %d\n", err);1269 1270 err = usb_reset_configuration(dev);1271 if (err < 0)1272 dev_dbg(&dev->dev, "MBOX3: error usb_reset_configuration: %d\n", err);1273 1274 dev_dbg(&dev->dev, "MBOX3: new boot length = %d\n",1275 le16_to_cpu(get_cfg_desc(config)->wTotalLength));1276 1277 mbox3_setup_defaults(dev);1278 dev_info(&dev->dev, "MBOX3: Initialized.");1279 1280 return 0; /* Successful boot */1281}1282 1283#define MICROBOOK_BUF_SIZE 1281284 1285static int snd_usb_motu_microbookii_communicate(struct usb_device *dev, u8 *buf,1286 int buf_size, int *length)1287{1288 int err, actual_length;1289 1290 if (usb_pipe_type_check(dev, usb_sndintpipe(dev, 0x01)))1291 return -EINVAL;1292 err = usb_interrupt_msg(dev, usb_sndintpipe(dev, 0x01), buf, *length,1293 &actual_length, 1000);1294 if (err < 0)1295 return err;1296 1297 print_hex_dump(KERN_DEBUG, "MicroBookII snd: ", DUMP_PREFIX_NONE, 16, 1,1298 buf, actual_length, false);1299 1300 memset(buf, 0, buf_size);1301 1302 if (usb_pipe_type_check(dev, usb_rcvintpipe(dev, 0x82)))1303 return -EINVAL;1304 err = usb_interrupt_msg(dev, usb_rcvintpipe(dev, 0x82), buf, buf_size,1305 &actual_length, 1000);1306 if (err < 0)1307 return err;1308 1309 print_hex_dump(KERN_DEBUG, "MicroBookII rcv: ", DUMP_PREFIX_NONE, 16, 1,1310 buf, actual_length, false);1311 1312 *length = actual_length;1313 return 0;1314}1315 1316static int snd_usb_motu_microbookii_boot_quirk(struct usb_device *dev)1317{1318 int err, actual_length, poll_attempts = 0;1319 static const u8 set_samplerate_seq[] = { 0x00, 0x00, 0x00, 0x00,1320 0x00, 0x00, 0x0b, 0x14,1321 0x00, 0x00, 0x00, 0x01 };1322 static const u8 poll_ready_seq[] = { 0x00, 0x04, 0x00, 0x00,1323 0x00, 0x00, 0x0b, 0x18 };1324 u8 *buf = kzalloc(MICROBOOK_BUF_SIZE, GFP_KERNEL);1325 1326 if (!buf)1327 return -ENOMEM;1328 1329 dev_info(&dev->dev, "Waiting for MOTU Microbook II to boot up...\n");1330 1331 /* First we tell the device which sample rate to use. */1332 memcpy(buf, set_samplerate_seq, sizeof(set_samplerate_seq));1333 actual_length = sizeof(set_samplerate_seq);1334 err = snd_usb_motu_microbookii_communicate(dev, buf, MICROBOOK_BUF_SIZE,1335 &actual_length);1336 1337 if (err < 0) {1338 dev_err(&dev->dev,1339 "failed setting the sample rate for Motu MicroBook II: %d\n",1340 err);1341 goto free_buf;1342 }1343 1344 /* Then we poll every 100 ms until the device informs of its readiness. */1345 while (true) {1346 if (++poll_attempts > 100) {1347 dev_err(&dev->dev,1348 "failed booting Motu MicroBook II: timeout\n");1349 err = -ENODEV;1350 goto free_buf;1351 }1352 1353 memset(buf, 0, MICROBOOK_BUF_SIZE);1354 memcpy(buf, poll_ready_seq, sizeof(poll_ready_seq));1355 1356 actual_length = sizeof(poll_ready_seq);1357 err = snd_usb_motu_microbookii_communicate(1358 dev, buf, MICROBOOK_BUF_SIZE, &actual_length);1359 if (err < 0) {1360 dev_err(&dev->dev,1361 "failed booting Motu MicroBook II: communication error %d\n",1362 err);1363 goto free_buf;1364 }1365 1366 /* the device signals its readiness through a message of the1367 * form1368 * XX 06 00 00 00 00 0b 18 00 00 00 011369 * If the device is not yet ready to accept audio data, the1370 * last byte of that sequence is 00.1371 */1372 if (actual_length == 12 && buf[actual_length - 1] == 1)1373 break;1374 1375 msleep(100);1376 }1377 1378 dev_info(&dev->dev, "MOTU MicroBook II ready\n");1379 1380free_buf:1381 kfree(buf);1382 return err;1383}1384 1385static int snd_usb_motu_m_series_boot_quirk(struct usb_device *dev)1386{1387 msleep(4000);1388 1389 return 0;1390}1391 1392static int snd_usb_rme_digiface_boot_quirk(struct usb_device *dev)1393{1394 /* Disable mixer, internal clock, all outputs ADAT, 48kHz, TMS off */1395 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1396 16, 0x40, 0x2410, 0x7fff, NULL, 0);1397 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1398 18, 0x40, 0x0104, 0xffff, NULL, 0);1399 1400 /* Disable loopback for all inputs */1401 for (int ch = 0; ch < 32; ch++)1402 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1403 22, 0x40, 0x400, ch, NULL, 0);1404 1405 /* Unity gain for all outputs */1406 for (int ch = 0; ch < 34; ch++)1407 snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0),1408 21, 0x40, 0x9000, 0x100 + ch, NULL, 0);1409 1410 return 0;1411}1412 1413/*1414 * Setup quirks1415 */1416#define MAUDIO_SET 0x01 /* parse device_setup */1417#define MAUDIO_SET_COMPATIBLE 0x80 /* use only "win-compatible" interfaces */1418#define MAUDIO_SET_DTS 0x02 /* enable DTS Digital Output */1419#define MAUDIO_SET_96K 0x04 /* 48-96kHz rate if set, 8-48kHz otherwise */1420#define MAUDIO_SET_24B 0x08 /* 24bits sample if set, 16bits otherwise */1421#define MAUDIO_SET_DI 0x10 /* enable Digital Input */1422#define MAUDIO_SET_MASK 0x1f /* bit mask for setup value */1423#define MAUDIO_SET_24B_48K_DI 0x19 /* 24bits+48kHz+Digital Input */1424#define MAUDIO_SET_24B_48K_NOTDI 0x09 /* 24bits+48kHz+No Digital Input */1425#define MAUDIO_SET_16B_48K_DI 0x11 /* 16bits+48kHz+Digital Input */1426#define MAUDIO_SET_16B_48K_NOTDI 0x01 /* 16bits+48kHz+No Digital Input */1427 1428static int quattro_skip_setting_quirk(struct snd_usb_audio *chip,1429 int iface, int altno)1430{1431 /* Reset ALL ifaces to 0 altsetting.1432 * Call it for every possible altsetting of every interface.1433 */1434 usb_set_interface(chip->dev, iface, 0);1435 if (chip->setup & MAUDIO_SET) {1436 if (chip->setup & MAUDIO_SET_COMPATIBLE) {1437 if (iface != 1 && iface != 2)1438 return 1; /* skip all interfaces but 1 and 2 */1439 } else {1440 unsigned int mask;1441 if (iface == 1 || iface == 2)1442 return 1; /* skip interfaces 1 and 2 */1443 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)1444 return 1; /* skip this altsetting */1445 mask = chip->setup & MAUDIO_SET_MASK;1446 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)1447 return 1; /* skip this altsetting */1448 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)1449 return 1; /* skip this altsetting */1450 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 4)1451 return 1; /* skip this altsetting */1452 }1453 }1454 usb_audio_dbg(chip,1455 "using altsetting %d for interface %d config %d\n",1456 altno, iface, chip->setup);1457 return 0; /* keep this altsetting */1458}1459 1460static int audiophile_skip_setting_quirk(struct snd_usb_audio *chip,1461 int iface,1462 int altno)1463{1464 /* Reset ALL ifaces to 0 altsetting.1465 * Call it for every possible altsetting of every interface.1466 */1467 usb_set_interface(chip->dev, iface, 0);1468 1469 if (chip->setup & MAUDIO_SET) {1470 unsigned int mask;1471 if ((chip->setup & MAUDIO_SET_DTS) && altno != 6)1472 return 1; /* skip this altsetting */1473 if ((chip->setup & MAUDIO_SET_96K) && altno != 1)1474 return 1; /* skip this altsetting */1475 mask = chip->setup & MAUDIO_SET_MASK;1476 if (mask == MAUDIO_SET_24B_48K_DI && altno != 2)1477 return 1; /* skip this altsetting */1478 if (mask == MAUDIO_SET_24B_48K_NOTDI && altno != 3)1479 return 1; /* skip this altsetting */1480 if (mask == MAUDIO_SET_16B_48K_DI && altno != 4)1481 return 1; /* skip this altsetting */1482 if (mask == MAUDIO_SET_16B_48K_NOTDI && altno != 5)1483 return 1; /* skip this altsetting */1484 }1485 1486 return 0; /* keep this altsetting */1487}1488 1489static int fasttrackpro_skip_setting_quirk(struct snd_usb_audio *chip,1490 int iface, int altno)1491{1492 /* Reset ALL ifaces to 0 altsetting.1493 * Call it for every possible altsetting of every interface.1494 */1495 usb_set_interface(chip->dev, iface, 0);1496 1497 /* possible configuration where both inputs and only one output is1498 *used is not supported by the current setup1499 */1500 if (chip->setup & (MAUDIO_SET | MAUDIO_SET_24B)) {1501 if (chip->setup & MAUDIO_SET_96K) {1502 if (altno != 3 && altno != 6)1503 return 1;1504 } else if (chip->setup & MAUDIO_SET_DI) {1505 if (iface == 4)1506 return 1; /* no analog input */1507 if (altno != 2 && altno != 5)1508 return 1; /* enable only altsets 2 and 5 */1509 } else {1510 if (iface == 5)1511 return 1; /* disable digialt input */1512 if (altno != 2 && altno != 5)1513 return 1; /* enalbe only altsets 2 and 5 */1514 }1515 } else {1516 /* keep only 16-Bit mode */1517 if (altno != 1)1518 return 1;1519 }1520 1521 usb_audio_dbg(chip,1522 "using altsetting %d for interface %d config %d\n",1523 altno, iface, chip->setup);1524 return 0; /* keep this altsetting */1525}1526 1527static int s1810c_skip_setting_quirk(struct snd_usb_audio *chip,1528 int iface, int altno)1529{1530 /*1531 * Altno settings:1532 *1533 * Playback (Interface 1):1534 * 1: 6 Analog + 2 S/PDIF1535 * 2: 6 Analog + 2 S/PDIF1536 * 3: 6 Analog1537 *1538 * Capture (Interface 2):1539 * 1: 8 Analog + 2 S/PDIF + 8 ADAT1540 * 2: 8 Analog + 2 S/PDIF + 4 ADAT1541 * 3: 8 Analog1542 */1543 1544 /*1545 * I'll leave 2 as the default one and1546 * use device_setup to switch to the1547 * other two.1548 */1549 if ((chip->setup == 0 || chip->setup > 2) && altno != 2)1550 return 1;1551 else if (chip->setup == 1 && altno != 1)1552 return 1;1553 else if (chip->setup == 2 && altno != 3)1554 return 1;1555 1556 return 0;1557}1558 1559int snd_usb_apply_interface_quirk(struct snd_usb_audio *chip,1560 int iface,1561 int altno)1562{1563 /* audiophile usb: skip altsets incompatible with device_setup */1564 if (chip->usb_id == USB_ID(0x0763, 0x2003))1565 return audiophile_skip_setting_quirk(chip, iface, altno);1566 /* quattro usb: skip altsets incompatible with device_setup */1567 if (chip->usb_id == USB_ID(0x0763, 0x2001))1568 return quattro_skip_setting_quirk(chip, iface, altno);1569 /* fasttrackpro usb: skip altsets incompatible with device_setup */1570 if (chip->usb_id == USB_ID(0x0763, 0x2012))1571 return fasttrackpro_skip_setting_quirk(chip, iface, altno);1572 /* presonus studio 1810c: skip altsets incompatible with device_setup */1573 if (chip->usb_id == USB_ID(0x194f, 0x010c))1574 return s1810c_skip_setting_quirk(chip, iface, altno);1575 1576 1577 return 0;1578}1579 1580int snd_usb_apply_boot_quirk(struct usb_device *dev,1581 struct usb_interface *intf,1582 const struct snd_usb_audio_quirk *quirk,1583 unsigned int id)1584{1585 switch (id) {1586 case USB_ID(0x041e, 0x3000):1587 /* SB Extigy needs special boot-up sequence */1588 /* if more models come, this will go to the quirk list. */1589 return snd_usb_extigy_boot_quirk(dev, intf);1590 1591 case USB_ID(0x041e, 0x3020):1592 /* SB Audigy 2 NX needs its own boot-up magic, too */1593 return snd_usb_audigy2nx_boot_quirk(dev);1594 1595 case USB_ID(0x10f5, 0x0200):1596 /* C-Media CM106 / Turtle Beach Audio Advantage Roadie */1597 return snd_usb_cm106_boot_quirk(dev);1598 1599 case USB_ID(0x0d8c, 0x0102):1600 /* C-Media CM6206 / CM106-Like Sound Device */1601 case USB_ID(0x0ccd, 0x00b1): /* Terratec Aureon 7.1 USB */1602 return snd_usb_cm6206_boot_quirk(dev);1603 1604 case USB_ID(0x0dba, 0x3000):1605 /* Digidesign Mbox 2 */1606 return snd_usb_mbox2_boot_quirk(dev);1607 case USB_ID(0x0dba, 0x5000):1608 /* Digidesign Mbox 3 */1609 return snd_usb_mbox3_boot_quirk(dev);1610 1611 1612 case USB_ID(0x1235, 0x0010): /* Focusrite Novation Saffire 6 USB */1613 case USB_ID(0x1235, 0x0018): /* Focusrite Novation Twitch */1614 return snd_usb_novation_boot_quirk(dev);1615 1616 case USB_ID(0x133e, 0x0815):1617 /* Access Music VirusTI Desktop */1618 return snd_usb_accessmusic_boot_quirk(dev);1619 1620 case USB_ID(0x17cc, 0x1000): /* Komplete Audio 6 */1621 case USB_ID(0x17cc, 0x1010): /* Traktor Audio 6 */1622 case USB_ID(0x17cc, 0x1020): /* Traktor Audio 10 */1623 return snd_usb_nativeinstruments_boot_quirk(dev);1624 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */1625 return snd_usb_fasttrackpro_boot_quirk(dev);1626 case USB_ID(0x047f, 0xc010): /* Plantronics Gamecom 780 */1627 return snd_usb_gamecon780_boot_quirk(dev);1628 case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx 3 */1629 return snd_usb_axefx3_boot_quirk(dev);1630 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */1631 /*1632 * For some reason interface 3 with vendor-spec class is1633 * detected on MicroBook IIc.1634 */1635 if (get_iface_desc(intf->altsetting)->bInterfaceClass ==1636 USB_CLASS_VENDOR_SPEC &&1637 get_iface_desc(intf->altsetting)->bInterfaceNumber < 3)1638 return snd_usb_motu_microbookii_boot_quirk(dev);1639 break;1640 case USB_ID(0x2a39, 0x3f8c): /* RME Digiface USB */1641 return snd_usb_rme_digiface_boot_quirk(dev);1642 }1643 1644 return 0;1645}1646 1647int snd_usb_apply_boot_quirk_once(struct usb_device *dev,1648 struct usb_interface *intf,1649 const struct snd_usb_audio_quirk *quirk,1650 unsigned int id)1651{1652 switch (id) {1653 case USB_ID(0x07fd, 0x0008): /* MOTU M Series, 1st hardware version */1654 return snd_usb_motu_m_series_boot_quirk(dev);1655 }1656 1657 return 0;1658}1659 1660/*1661 * check if the device uses big-endian samples1662 */1663int snd_usb_is_big_endian_format(struct snd_usb_audio *chip,1664 const struct audioformat *fp)1665{1666 /* it depends on altsetting whether the device is big-endian or not */1667 switch (chip->usb_id) {1668 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro: captured data only */1669 if (fp->altsetting == 2 || fp->altsetting == 3 ||1670 fp->altsetting == 5 || fp->altsetting == 6)1671 return 1;1672 break;1673 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */1674 if (chip->setup == 0x00 ||1675 fp->altsetting == 1 || fp->altsetting == 2 ||1676 fp->altsetting == 3)1677 return 1;1678 break;1679 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro */1680 if (fp->altsetting == 2 || fp->altsetting == 3 ||1681 fp->altsetting == 5 || fp->altsetting == 6)1682 return 1;1683 break;1684 }1685 return 0;1686}1687 1688/*1689 * For E-Mu 0404USB/0202USB/TrackerPre/0204 sample rate should be set for device,1690 * not for interface.1691 */1692 1693enum {1694 EMU_QUIRK_SR_44100HZ = 0,1695 EMU_QUIRK_SR_48000HZ,1696 EMU_QUIRK_SR_88200HZ,1697 EMU_QUIRK_SR_96000HZ,1698 EMU_QUIRK_SR_176400HZ,1699 EMU_QUIRK_SR_192000HZ1700};1701 1702static void set_format_emu_quirk(struct snd_usb_substream *subs,1703 const struct audioformat *fmt)1704{1705 unsigned char emu_samplerate_id = 0;1706 1707 /* When capture is active1708 * sample rate shouldn't be changed1709 * by playback substream1710 */1711 if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK) {1712 if (subs->stream->substream[SNDRV_PCM_STREAM_CAPTURE].cur_audiofmt)1713 return;1714 }1715 1716 switch (fmt->rate_min) {1717 case 48000:1718 emu_samplerate_id = EMU_QUIRK_SR_48000HZ;1719 break;1720 case 88200:1721 emu_samplerate_id = EMU_QUIRK_SR_88200HZ;1722 break;1723 case 96000:1724 emu_samplerate_id = EMU_QUIRK_SR_96000HZ;1725 break;1726 case 176400:1727 emu_samplerate_id = EMU_QUIRK_SR_176400HZ;1728 break;1729 case 192000:1730 emu_samplerate_id = EMU_QUIRK_SR_192000HZ;1731 break;1732 default:1733 emu_samplerate_id = EMU_QUIRK_SR_44100HZ;1734 break;1735 }1736 snd_emuusb_set_samplerate(subs->stream->chip, emu_samplerate_id);1737 subs->pkt_offset_adj = (emu_samplerate_id >= EMU_QUIRK_SR_176400HZ) ? 4 : 0;1738}1739 1740static int pioneer_djm_set_format_quirk(struct snd_usb_substream *subs,1741 u16 windex)1742{1743 unsigned int cur_rate = subs->data_endpoint->cur_rate;1744 u8 sr[3];1745 // Convert to little endian1746 sr[0] = cur_rate & 0xff;1747 sr[1] = (cur_rate >> 8) & 0xff;1748 sr[2] = (cur_rate >> 16) & 0xff;1749 usb_set_interface(subs->dev, 0, 1);1750 // we should derive windex from fmt-sync_ep but it's not set1751 snd_usb_ctl_msg(subs->stream->chip->dev,1752 usb_sndctrlpipe(subs->stream->chip->dev, 0),1753 0x01, 0x22, 0x0100, windex, &sr, 0x0003);1754 return 0;1755}1756 1757static void mbox3_set_format_quirk(struct snd_usb_substream *subs,1758 const struct audioformat *fmt)1759{1760 __le32 buff4 = 0;1761 u8 buff1 = 0x01;1762 u32 new_rate = subs->data_endpoint->cur_rate;1763 u32 current_rate;1764 1765 // Get current rate from card and check if changing it is needed1766 snd_usb_ctl_msg(subs->dev, usb_rcvctrlpipe(subs->dev, 0),1767 0x01, 0x21 | USB_DIR_IN, 0x0100, 0x8101, &buff4, 4);1768 current_rate = le32_to_cpu(buff4);1769 dev_dbg(&subs->dev->dev,1770 "MBOX3: Current configured sample rate: %d", current_rate);1771 if (current_rate == new_rate) {1772 dev_dbg(&subs->dev->dev,1773 "MBOX3: No change needed (current rate:%d == new rate:%d)",1774 current_rate, new_rate);1775 return;1776 }1777 1778 // Set new rate1779 dev_info(&subs->dev->dev,1780 "MBOX3: Changing sample rate to: %d", new_rate);1781 buff4 = cpu_to_le32(new_rate);1782 snd_usb_ctl_msg(subs->dev, usb_sndctrlpipe(subs->dev, 0),1783 0x01, 0x21, 0x0100, 0x8101, &buff4, 4);1784 1785 // Set clock source to Internal1786 snd_usb_ctl_msg(subs->dev, usb_sndctrlpipe(subs->dev, 0),1787 0x01, 0x21, 0x0100, 0x8001, &buff1, 1);1788 1789 // Check whether the change was successful1790 buff4 = 0;1791 snd_usb_ctl_msg(subs->dev, usb_rcvctrlpipe(subs->dev, 0),1792 0x01, 0x21 | USB_DIR_IN, 0x0100, 0x8101, &buff4, 4);1793 if (new_rate != le32_to_cpu(buff4))1794 dev_warn(&subs->dev->dev, "MBOX3: Couldn't set the sample rate");1795}1796 1797static const int rme_digiface_rate_table[] = {1798 32000, 44100, 48000, 0,1799 64000, 88200, 96000, 0,1800 128000, 176400, 192000, 0,1801};1802 1803static int rme_digiface_set_format_quirk(struct snd_usb_substream *subs)1804{1805 unsigned int cur_rate = subs->data_endpoint->cur_rate;1806 u16 val;1807 int speed_mode;1808 int id;1809 1810 for (id = 0; id < ARRAY_SIZE(rme_digiface_rate_table); id++) {1811 if (rme_digiface_rate_table[id] == cur_rate)1812 break;1813 }1814 1815 if (id >= ARRAY_SIZE(rme_digiface_rate_table))1816 return -EINVAL;1817 1818 /* 2, 3, 4 for 1x, 2x, 4x */1819 speed_mode = (id >> 2) + 2;1820 val = (id << 3) | (speed_mode << 12);1821 1822 /* Set the sample rate */1823 snd_usb_ctl_msg(subs->stream->chip->dev,1824 usb_sndctrlpipe(subs->stream->chip->dev, 0),1825 16, 0x40, val, 0x7078, NULL, 0);1826 return 0;1827}1828 1829void snd_usb_set_format_quirk(struct snd_usb_substream *subs,1830 const struct audioformat *fmt)1831{1832 switch (subs->stream->chip->usb_id) {1833 case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */1834 case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */1835 case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */1836 case USB_ID(0x041e, 0x3f19): /* E-Mu 0204 USB */1837 set_format_emu_quirk(subs, fmt);1838 break;1839 case USB_ID(0x534d, 0x0021): /* MacroSilicon MS2100/MS2106 */1840 case USB_ID(0x534d, 0x2109): /* MacroSilicon MS2109 */1841 subs->stream_offset_adj = 2;1842 break;1843 case USB_ID(0x2b73, 0x0013): /* Pioneer DJM-450 */1844 pioneer_djm_set_format_quirk(subs, 0x0082);1845 break;1846 case USB_ID(0x08e4, 0x017f): /* Pioneer DJM-750 */1847 case USB_ID(0x08e4, 0x0163): /* Pioneer DJM-850 */1848 pioneer_djm_set_format_quirk(subs, 0x0086);1849 break;1850 case USB_ID(0x0dba, 0x5000):1851 mbox3_set_format_quirk(subs, fmt); /* Digidesign Mbox 3 */1852 break;1853 case USB_ID(0x2a39, 0x3f8c): /* RME Digiface USB */1854 rme_digiface_set_format_quirk(subs);1855 break;1856 }1857}1858 1859int snd_usb_select_mode_quirk(struct snd_usb_audio *chip,1860 const struct audioformat *fmt)1861{1862 struct usb_device *dev = chip->dev;1863 int err;1864 1865 if (chip->quirk_flags & QUIRK_FLAG_ITF_USB_DSD_DAC) {1866 /* First switch to alt set 0, otherwise the mode switch cmd1867 * will not be accepted by the DAC1868 */1869 err = usb_set_interface(dev, fmt->iface, 0);1870 if (err < 0)1871 return err;1872 1873 msleep(20); /* Delay needed after setting the interface */1874 1875 /* Vendor mode switch cmd is required. */1876 if (fmt->formats & SNDRV_PCM_FMTBIT_DSD_U32_BE) {1877 /* DSD mode (DSD_U32) requested */1878 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,1879 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,1880 1, 1, NULL, 0);1881 if (err < 0)1882 return err;1883 1884 } else {1885 /* PCM or DOP mode (S32) requested */1886 /* PCM mode (S16) requested */1887 err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), 0,1888 USB_DIR_OUT|USB_TYPE_VENDOR|USB_RECIP_INTERFACE,1889 0, 1, NULL, 0);1890 if (err < 0)1891 return err;1892 1893 }1894 msleep(20);1895 }1896 return 0;1897}1898 1899void snd_usb_endpoint_start_quirk(struct snd_usb_endpoint *ep)1900{1901 /*1902 * "Playback Design" products send bogus feedback data at the start1903 * of the stream. Ignore them.1904 */1905 if (USB_ID_VENDOR(ep->chip->usb_id) == 0x23ba &&1906 ep->type == SND_USB_ENDPOINT_TYPE_SYNC)1907 ep->skip_packets = 4;1908 1909 /*1910 * M-Audio Fast Track C400/C600 - when packets are not skipped, real1911 * world latency varies by approx. +/- 50 frames (at 96kHz) each time1912 * the stream is (re)started. When skipping packets 16 at endpoint1913 * start up, the real world latency is stable within +/- 1 frame (also1914 * across power cycles).1915 */1916 if ((ep->chip->usb_id == USB_ID(0x0763, 0x2030) ||1917 ep->chip->usb_id == USB_ID(0x0763, 0x2031)) &&1918 ep->type == SND_USB_ENDPOINT_TYPE_DATA)1919 ep->skip_packets = 16;1920 1921 /* Work around devices that report unreasonable feedback data */1922 if ((ep->chip->usb_id == USB_ID(0x0644, 0x8038) || /* TEAC UD-H01 */1923 ep->chip->usb_id == USB_ID(0x1852, 0x5034)) && /* T+A Dac8 */1924 ep->syncmaxsize == 4)1925 ep->tenor_fb_quirk = 1;1926}1927 1928/* quirk applied after snd_usb_ctl_msg(); not applied during boot quirks */1929void snd_usb_ctl_msg_quirk(struct usb_device *dev, unsigned int pipe,1930 __u8 request, __u8 requesttype, __u16 value,1931 __u16 index, void *data, __u16 size)1932{1933 struct snd_usb_audio *chip = dev_get_drvdata(&dev->dev);1934 1935 if (!chip || (requesttype & USB_TYPE_MASK) != USB_TYPE_CLASS)1936 return;1937 1938 if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY)1939 msleep(20);1940 else if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY_1M)1941 usleep_range(1000, 2000);1942 else if (chip->quirk_flags & QUIRK_FLAG_CTL_MSG_DELAY_5M)1943 usleep_range(5000, 6000);1944}1945 1946/*1947 * snd_usb_interface_dsd_format_quirks() is called from format.c to1948 * augment the PCM format bit-field for DSD types. The UAC standards1949 * don't have a designated bit field to denote DSD-capable interfaces,1950 * hence all hardware that is known to support this format has to be1951 * listed here.1952 */1953u64 snd_usb_interface_dsd_format_quirks(struct snd_usb_audio *chip,1954 struct audioformat *fp,1955 unsigned int sample_bytes)1956{1957 struct usb_interface *iface;1958 1959 /* Playback Designs */1960 if (USB_ID_VENDOR(chip->usb_id) == 0x23ba &&1961 USB_ID_PRODUCT(chip->usb_id) < 0x0110) {1962 switch (fp->altsetting) {1963 case 1:1964 fp->dsd_dop = true;1965 return SNDRV_PCM_FMTBIT_DSD_U16_LE;1966 case 2:1967 fp->dsd_bitrev = true;1968 return SNDRV_PCM_FMTBIT_DSD_U8;1969 case 3:1970 fp->dsd_bitrev = true;1971 return SNDRV_PCM_FMTBIT_DSD_U16_LE;1972 }1973 }1974 1975 /* XMOS based USB DACs */1976 switch (chip->usb_id) {1977 case USB_ID(0x139f, 0x5504): /* Nagra DAC */1978 case USB_ID(0x20b1, 0x3089): /* Mola-Mola DAC */1979 case USB_ID(0x2522, 0x0007): /* LH Labs Geek Out 1V5 */1980 case USB_ID(0x2522, 0x0009): /* LH Labs Geek Pulse X Inifinity 2V0 */1981 case USB_ID(0x2522, 0x0012): /* LH Labs VI DAC Infinity */1982 case USB_ID(0x2772, 0x0230): /* Pro-Ject Pre Box S2 Digital */1983 if (fp->altsetting == 2)1984 return SNDRV_PCM_FMTBIT_DSD_U32_BE;1985 break;1986 1987 case USB_ID(0x0d8c, 0x0316): /* Hegel HD12 DSD */1988 case USB_ID(0x10cb, 0x0103): /* The Bit Opus #3; with fp->dsd_raw */1989 case USB_ID(0x16d0, 0x06b2): /* NuPrime DAC-10 */1990 case USB_ID(0x16d0, 0x06b4): /* NuPrime Audio HD-AVP/AVA */1991 case USB_ID(0x16d0, 0x0733): /* Furutech ADL Stratos */1992 case USB_ID(0x16d0, 0x09d8): /* NuPrime IDA-8 */1993 case USB_ID(0x16d0, 0x09db): /* NuPrime Audio DAC-9 */1994 case USB_ID(0x16d0, 0x09dd): /* Encore mDSD */1995 case USB_ID(0x1db5, 0x0003): /* Bryston BDA3 */1996 case USB_ID(0x20a0, 0x4143): /* WaveIO USB Audio 2.0 */1997 case USB_ID(0x22e1, 0xca01): /* HDTA Serenade DSD */1998 case USB_ID(0x249c, 0x9326): /* M2Tech Young MkIII */1999 case USB_ID(0x2616, 0x0106): /* PS Audio NuWave DAC */2000 case USB_ID(0x2622, 0x0041): /* Audiolab M-DAC+ */2001 case USB_ID(0x278b, 0x5100): /* Rotel RC-1590 */2002 case USB_ID(0x27f7, 0x3002): /* W4S DAC-2v2SE */2003 case USB_ID(0x29a2, 0x0086): /* Mutec MC3+ USB */2004 case USB_ID(0x6b42, 0x0042): /* MSB Technology */2005 if (fp->altsetting == 3)2006 return SNDRV_PCM_FMTBIT_DSD_U32_BE;2007 break;2008 2009 /* Amanero Combo384 USB based DACs with native DSD support */2010 case USB_ID(0x16d0, 0x071a): /* Amanero - Combo384 */2011 if (fp->altsetting == 2) {2012 switch (le16_to_cpu(chip->dev->descriptor.bcdDevice)) {2013 case 0x199:2014 return SNDRV_PCM_FMTBIT_DSD_U32_LE;2015 case 0x19b:2016 case 0x203:2017 return SNDRV_PCM_FMTBIT_DSD_U32_BE;2018 default:2019 break;2020 }2021 }2022 break;2023 case USB_ID(0x16d0, 0x0a23):2024 if (fp->altsetting == 2)2025 return SNDRV_PCM_FMTBIT_DSD_U32_BE;2026 break;2027 2028 default:2029 break;2030 }2031 2032 /* ITF-USB DSD based DACs */2033 if (chip->quirk_flags & QUIRK_FLAG_ITF_USB_DSD_DAC) {2034 iface = usb_ifnum_to_if(chip->dev, fp->iface);2035 2036 /* Altsetting 2 support native DSD if the num of altsets is2037 * three (0-2),2038 * Altsetting 3 support native DSD if the num of altsets is2039 * four (0-3).2040 */2041 if (fp->altsetting == iface->num_altsetting - 1)2042 return SNDRV_PCM_FMTBIT_DSD_U32_BE;2043 }2044 2045 /* Mostly generic method to detect many DSD-capable implementations */2046 if ((chip->quirk_flags & QUIRK_FLAG_DSD_RAW) && fp->dsd_raw)2047 return SNDRV_PCM_FMTBIT_DSD_U32_BE;2048 2049 return 0;2050}2051 2052void snd_usb_audioformat_attributes_quirk(struct snd_usb_audio *chip,2053 struct audioformat *fp,2054 int stream)2055{2056 switch (chip->usb_id) {2057 case USB_ID(0x0a92, 0x0053): /* AudioTrak Optoplay */2058 /* Optoplay sets the sample rate attribute although2059 * it seems not supporting it in fact.2060 */2061 fp->attributes &= ~UAC_EP_CS_ATTR_SAMPLE_RATE;2062 break;2063 case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */2064 case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */2065 /* doesn't set the sample rate attribute, but supports it */2066 fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE;2067 break;2068 case USB_ID(0x0763, 0x2001): /* M-Audio Quattro USB */2069 case USB_ID(0x0763, 0x2012): /* M-Audio Fast Track Pro USB */2070 case USB_ID(0x047f, 0x0ca1): /* plantronics headset */2071 case USB_ID(0x077d, 0x07af): /* Griffin iMic (note that there is2072 an older model 77d:223) */2073 /*2074 * plantronics headset and Griffin iMic have set adaptive-in2075 * although it's really not...2076 */2077 fp->ep_attr &= ~USB_ENDPOINT_SYNCTYPE;2078 if (stream == SNDRV_PCM_STREAM_PLAYBACK)2079 fp->ep_attr |= USB_ENDPOINT_SYNC_ADAPTIVE;2080 else2081 fp->ep_attr |= USB_ENDPOINT_SYNC_SYNC;2082 break;2083 case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook IIc */2084 /*2085 * MaxPacketsOnly attribute is erroneously set in endpoint2086 * descriptors. As a result this card produces noise with2087 * all sample rates other than 96 kHz.2088 */2089 fp->attributes &= ~UAC_EP_CS_ATTR_FILL_MAX;2090 break;2091 case USB_ID(0x1224, 0x2a25): /* Jieli Technology USB PHY 2.0 */2092 /* mic works only when ep packet size is set to wMaxPacketSize */2093 fp->attributes |= UAC_EP_CS_ATTR_FILL_MAX;2094 break;2095 case USB_ID(0x3511, 0x2b1e): /* Opencomm2 UC USB Bluetooth dongle */2096 /* mic works only when ep pitch control is not set */2097 if (stream == SNDRV_PCM_STREAM_CAPTURE)2098 fp->attributes &= ~UAC_EP_CS_ATTR_PITCH_CONTROL;2099 break;2100 }2101}2102 2103/*2104 * driver behavior quirk flags2105 */2106struct usb_audio_quirk_flags_table {2107 u32 id;2108 u32 flags;2109};2110 2111#define DEVICE_FLG(vid, pid, _flags) \2112 { .id = USB_ID(vid, pid), .flags = (_flags) }2113#define VENDOR_FLG(vid, _flags) DEVICE_FLG(vid, 0, _flags)2114 2115static const struct usb_audio_quirk_flags_table quirk_flags_table[] = {2116 /* Device matches */2117 DEVICE_FLG(0x03f0, 0x654a, /* HP 320 FHD Webcam */2118 QUIRK_FLAG_GET_SAMPLE_RATE),2119 DEVICE_FLG(0x041e, 0x3000, /* Creative SB Extigy */2120 QUIRK_FLAG_IGNORE_CTL_ERROR),2121 DEVICE_FLG(0x041e, 0x4080, /* Creative Live Cam VF0610 */2122 QUIRK_FLAG_GET_SAMPLE_RATE),2123 DEVICE_FLG(0x045e, 0x083c, /* MS USB Link headset */2124 QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY |2125 QUIRK_FLAG_DISABLE_AUTOSUSPEND),2126 DEVICE_FLG(0x046d, 0x084c, /* Logitech ConferenceCam Connect */2127 QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY_1M),2128 DEVICE_FLG(0x046d, 0x0991, /* Logitech QuickCam Pro */2129 QUIRK_FLAG_CTL_MSG_DELAY_1M | QUIRK_FLAG_IGNORE_CTL_ERROR),2130 DEVICE_FLG(0x046d, 0x09a4, /* Logitech QuickCam E 3500 */2131 QUIRK_FLAG_CTL_MSG_DELAY_1M | QUIRK_FLAG_IGNORE_CTL_ERROR),2132 DEVICE_FLG(0x0499, 0x1509, /* Steinberg UR22 */2133 QUIRK_FLAG_GENERIC_IMPLICIT_FB),2134 DEVICE_FLG(0x0499, 0x3108, /* Yamaha YIT-W12TX */2135 QUIRK_FLAG_GET_SAMPLE_RATE),2136 DEVICE_FLG(0x04d8, 0xfeea, /* Benchmark DAC1 Pre */2137 QUIRK_FLAG_GET_SAMPLE_RATE),2138 DEVICE_FLG(0x04e8, 0xa051, /* Samsung USBC Headset (AKG) */2139 QUIRK_FLAG_SKIP_CLOCK_SELECTOR | QUIRK_FLAG_CTL_MSG_DELAY_5M),2140 DEVICE_FLG(0x0525, 0xa4ad, /* Hamedal C20 usb camero */2141 QUIRK_FLAG_IFACE_SKIP_CLOSE),2142 DEVICE_FLG(0x054c, 0x0b8c, /* Sony WALKMAN NW-A45 DAC */2143 QUIRK_FLAG_SET_IFACE_FIRST),2144 DEVICE_FLG(0x0556, 0x0014, /* Phoenix Audio TMX320VC */2145 QUIRK_FLAG_GET_SAMPLE_RATE),2146 DEVICE_FLG(0x05a3, 0x9420, /* ELP HD USB Camera */2147 QUIRK_FLAG_GET_SAMPLE_RATE),2148 DEVICE_FLG(0x05a7, 0x1020, /* Bose Companion 5 */2149 QUIRK_FLAG_GET_SAMPLE_RATE),2150 DEVICE_FLG(0x05e1, 0x0408, /* Syntek STK1160 */2151 QUIRK_FLAG_ALIGN_TRANSFER),2152 DEVICE_FLG(0x05e1, 0x0480, /* Hauppauge Woodbury */2153 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2154 DEVICE_FLG(0x0644, 0x8043, /* TEAC UD-501/UD-501V2/UD-503/NT-503 */2155 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |2156 QUIRK_FLAG_IFACE_DELAY),2157 DEVICE_FLG(0x0644, 0x8044, /* Esoteric D-05X */2158 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |2159 QUIRK_FLAG_IFACE_DELAY),2160 DEVICE_FLG(0x0644, 0x804a, /* TEAC UD-301 */2161 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |2162 QUIRK_FLAG_IFACE_DELAY),2163 DEVICE_FLG(0x0644, 0x805f, /* TEAC Model 12 */2164 QUIRK_FLAG_FORCE_IFACE_RESET),2165 DEVICE_FLG(0x0644, 0x806b, /* TEAC UD-701 */2166 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY |2167 QUIRK_FLAG_IFACE_DELAY),2168 DEVICE_FLG(0x06f8, 0xb000, /* Hercules DJ Console (Windows Edition) */2169 QUIRK_FLAG_IGNORE_CTL_ERROR),2170 DEVICE_FLG(0x06f8, 0xd002, /* Hercules DJ Console (Macintosh Edition) */2171 QUIRK_FLAG_IGNORE_CTL_ERROR),2172 DEVICE_FLG(0x0711, 0x5800, /* MCT Trigger 5 USB-to-HDMI */2173 QUIRK_FLAG_GET_SAMPLE_RATE),2174 DEVICE_FLG(0x074d, 0x3553, /* Outlaw RR2150 (Micronas UAC3553B) */2175 QUIRK_FLAG_GET_SAMPLE_RATE),2176 DEVICE_FLG(0x0763, 0x2030, /* M-Audio Fast Track C400 */2177 QUIRK_FLAG_GENERIC_IMPLICIT_FB),2178 DEVICE_FLG(0x0763, 0x2031, /* M-Audio Fast Track C600 */2179 QUIRK_FLAG_GENERIC_IMPLICIT_FB),2180 DEVICE_FLG(0x07fd, 0x000b, /* MOTU M Series 2nd hardware revision */2181 QUIRK_FLAG_CTL_MSG_DELAY_1M),2182 DEVICE_FLG(0x08bb, 0x2702, /* LineX FM Transmitter */2183 QUIRK_FLAG_IGNORE_CTL_ERROR),2184 DEVICE_FLG(0x0951, 0x16ad, /* Kingston HyperX */2185 QUIRK_FLAG_CTL_MSG_DELAY_1M),2186 DEVICE_FLG(0x0b0e, 0x0349, /* Jabra 550a */2187 QUIRK_FLAG_CTL_MSG_DELAY_1M),2188 DEVICE_FLG(0x0c45, 0x6340, /* Sonix HD USB Camera */2189 QUIRK_FLAG_GET_SAMPLE_RATE),2190 DEVICE_FLG(0x0ecb, 0x205c, /* JBL Quantum610 Wireless */2191 QUIRK_FLAG_FIXED_RATE),2192 DEVICE_FLG(0x0ecb, 0x2069, /* JBL Quantum810 Wireless */2193 QUIRK_FLAG_FIXED_RATE),2194 DEVICE_FLG(0x0fd9, 0x0008, /* Hauppauge HVR-950Q */2195 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2196 DEVICE_FLG(0x1224, 0x2a25, /* Jieli Technology USB PHY 2.0 */2197 QUIRK_FLAG_GET_SAMPLE_RATE),2198 DEVICE_FLG(0x1395, 0x740a, /* Sennheiser DECT */2199 QUIRK_FLAG_GET_SAMPLE_RATE),2200 DEVICE_FLG(0x1397, 0x0507, /* Behringer UMC202HD */2201 QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB),2202 DEVICE_FLG(0x1397, 0x0508, /* Behringer UMC204HD */2203 QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB),2204 DEVICE_FLG(0x1397, 0x0509, /* Behringer UMC404HD */2205 QUIRK_FLAG_PLAYBACK_FIRST | QUIRK_FLAG_GENERIC_IMPLICIT_FB),2206 DEVICE_FLG(0x13e5, 0x0001, /* Serato Phono */2207 QUIRK_FLAG_IGNORE_CTL_ERROR),2208 DEVICE_FLG(0x154e, 0x1002, /* Denon DCD-1500RE */2209 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),2210 DEVICE_FLG(0x154e, 0x1003, /* Denon DA-300USB */2211 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),2212 DEVICE_FLG(0x154e, 0x3005, /* Marantz HD-DAC1 */2213 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),2214 DEVICE_FLG(0x154e, 0x3006, /* Marantz SA-14S1 */2215 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),2216 DEVICE_FLG(0x154e, 0x300b, /* Marantz SA-KI RUBY / SA-12 */2217 QUIRK_FLAG_DSD_RAW),2218 DEVICE_FLG(0x154e, 0x500e, /* Denon DN-X1600 */2219 QUIRK_FLAG_IGNORE_CLOCK_SOURCE),2220 DEVICE_FLG(0x1686, 0x00dd, /* Zoom R16/24 */2221 QUIRK_FLAG_TX_LENGTH | QUIRK_FLAG_CTL_MSG_DELAY_1M),2222 DEVICE_FLG(0x17aa, 0x1046, /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */2223 QUIRK_FLAG_DISABLE_AUTOSUSPEND),2224 DEVICE_FLG(0x17aa, 0x104d, /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */2225 QUIRK_FLAG_DISABLE_AUTOSUSPEND),2226 DEVICE_FLG(0x1852, 0x5062, /* Luxman D-08u */2227 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),2228 DEVICE_FLG(0x1852, 0x5065, /* Luxman DA-06 */2229 QUIRK_FLAG_ITF_USB_DSD_DAC | QUIRK_FLAG_CTL_MSG_DELAY),2230 DEVICE_FLG(0x1901, 0x0191, /* GE B850V3 CP2114 audio interface */2231 QUIRK_FLAG_GET_SAMPLE_RATE),2232 DEVICE_FLG(0x19f7, 0x0035, /* RODE NT-USB+ */2233 QUIRK_FLAG_GET_SAMPLE_RATE),2234 DEVICE_FLG(0x1bcf, 0x2281, /* HD Webcam */2235 QUIRK_FLAG_GET_SAMPLE_RATE),2236 DEVICE_FLG(0x1bcf, 0x2283, /* NexiGo N930AF FHD Webcam */2237 QUIRK_FLAG_GET_SAMPLE_RATE),2238 DEVICE_FLG(0x2040, 0x7200, /* Hauppauge HVR-950Q */2239 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2240 DEVICE_FLG(0x2040, 0x7201, /* Hauppauge HVR-950Q-MXL */2241 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2242 DEVICE_FLG(0x2040, 0x7210, /* Hauppauge HVR-950Q */2243 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2244 DEVICE_FLG(0x2040, 0x7211, /* Hauppauge HVR-950Q-MXL */2245 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2246 DEVICE_FLG(0x2040, 0x7213, /* Hauppauge HVR-950Q */2247 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2248 DEVICE_FLG(0x2040, 0x7217, /* Hauppauge HVR-950Q */2249 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2250 DEVICE_FLG(0x2040, 0x721b, /* Hauppauge HVR-950Q */2251 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2252 DEVICE_FLG(0x2040, 0x721e, /* Hauppauge HVR-950Q */2253 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2254 DEVICE_FLG(0x2040, 0x721f, /* Hauppauge HVR-950Q */2255 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2256 DEVICE_FLG(0x2040, 0x7240, /* Hauppauge HVR-850 */2257 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2258 DEVICE_FLG(0x2040, 0x7260, /* Hauppauge HVR-950Q */2259 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2260 DEVICE_FLG(0x2040, 0x7270, /* Hauppauge HVR-950Q */2261 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2262 DEVICE_FLG(0x2040, 0x7280, /* Hauppauge HVR-950Q */2263 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2264 DEVICE_FLG(0x2040, 0x7281, /* Hauppauge HVR-950Q-MXL */2265 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2266 DEVICE_FLG(0x2040, 0x8200, /* Hauppauge Woodbury */2267 QUIRK_FLAG_SHARE_MEDIA_DEVICE | QUIRK_FLAG_ALIGN_TRANSFER),2268 DEVICE_FLG(0x21b4, 0x0081, /* AudioQuest DragonFly */2269 QUIRK_FLAG_GET_SAMPLE_RATE),2270 DEVICE_FLG(0x21b4, 0x0230, /* Ayre QB-9 Twenty */2271 QUIRK_FLAG_DSD_RAW),2272 DEVICE_FLG(0x21b4, 0x0232, /* Ayre QX-5 Twenty */2273 QUIRK_FLAG_DSD_RAW),2274 DEVICE_FLG(0x2522, 0x0007, /* LH Labs Geek Out HD Audio 1V5 */2275 QUIRK_FLAG_SET_IFACE_FIRST),2276 DEVICE_FLG(0x2708, 0x0002, /* Audient iD14 */2277 QUIRK_FLAG_IGNORE_CTL_ERROR),2278 DEVICE_FLG(0x2912, 0x30c8, /* Audioengine D1 */2279 QUIRK_FLAG_GET_SAMPLE_RATE),2280 DEVICE_FLG(0x2b53, 0x0023, /* Fiero SC-01 (firmware v1.0.0 @ 48 kHz) */2281 QUIRK_FLAG_GENERIC_IMPLICIT_FB),2282 DEVICE_FLG(0x2b53, 0x0024, /* Fiero SC-01 (firmware v1.0.0 @ 96 kHz) */2283 QUIRK_FLAG_GENERIC_IMPLICIT_FB),2284 DEVICE_FLG(0x2b53, 0x0031, /* Fiero SC-01 (firmware v1.1.0) */2285 QUIRK_FLAG_GENERIC_IMPLICIT_FB),2286 DEVICE_FLG(0x2d95, 0x8011, /* VIVO USB-C HEADSET */2287 QUIRK_FLAG_CTL_MSG_DELAY_1M),2288 DEVICE_FLG(0x2d95, 0x8021, /* VIVO USB-C-XE710 HEADSET */2289 QUIRK_FLAG_CTL_MSG_DELAY_1M),2290 DEVICE_FLG(0x30be, 0x0101, /* Schiit Hel */2291 QUIRK_FLAG_IGNORE_CTL_ERROR),2292 DEVICE_FLG(0x413c, 0xa506, /* Dell AE515 sound bar */2293 QUIRK_FLAG_GET_SAMPLE_RATE),2294 DEVICE_FLG(0x534d, 0x0021, /* MacroSilicon MS2100/MS2106 */2295 QUIRK_FLAG_ALIGN_TRANSFER),2296 DEVICE_FLG(0x534d, 0x2109, /* MacroSilicon MS2109 */2297 QUIRK_FLAG_ALIGN_TRANSFER),2298 2299 /* Vendor matches */2300 VENDOR_FLG(0x045e, /* MS Lifecam */2301 QUIRK_FLAG_GET_SAMPLE_RATE),2302 VENDOR_FLG(0x046d, /* Logitech */2303 QUIRK_FLAG_CTL_MSG_DELAY_1M),2304 VENDOR_FLG(0x047f, /* Plantronics */2305 QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_CTL_MSG_DELAY),2306 VENDOR_FLG(0x0644, /* TEAC Corp. */2307 QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY),2308 VENDOR_FLG(0x07fd, /* MOTU */2309 QUIRK_FLAG_VALIDATE_RATES),2310 VENDOR_FLG(0x1235, /* Focusrite Novation */2311 QUIRK_FLAG_VALIDATE_RATES),2312 VENDOR_FLG(0x1511, /* AURALiC */2313 QUIRK_FLAG_DSD_RAW),2314 VENDOR_FLG(0x152a, /* Thesycon devices */2315 QUIRK_FLAG_DSD_RAW),2316 VENDOR_FLG(0x18d1, /* iBasso devices */2317 QUIRK_FLAG_DSD_RAW),2318 VENDOR_FLG(0x1de7, /* Phoenix Audio */2319 QUIRK_FLAG_GET_SAMPLE_RATE),2320 VENDOR_FLG(0x20b1, /* XMOS based devices */2321 QUIRK_FLAG_DSD_RAW),2322 VENDOR_FLG(0x21ed, /* Accuphase Laboratory */2323 QUIRK_FLAG_DSD_RAW),2324 VENDOR_FLG(0x22d9, /* Oppo */2325 QUIRK_FLAG_DSD_RAW),2326 VENDOR_FLG(0x23ba, /* Playback Design */2327 QUIRK_FLAG_CTL_MSG_DELAY | QUIRK_FLAG_IFACE_DELAY |2328 QUIRK_FLAG_DSD_RAW),2329 VENDOR_FLG(0x25ce, /* Mytek devices */2330 QUIRK_FLAG_DSD_RAW),2331 VENDOR_FLG(0x278b, /* Rotel? */2332 QUIRK_FLAG_DSD_RAW),2333 VENDOR_FLG(0x292b, /* Gustard/Ess based devices */2334 QUIRK_FLAG_DSD_RAW),2335 VENDOR_FLG(0x2972, /* FiiO devices */2336 QUIRK_FLAG_DSD_RAW),2337 VENDOR_FLG(0x2ab6, /* T+A devices */2338 QUIRK_FLAG_DSD_RAW),2339 VENDOR_FLG(0x2afd, /* McIntosh Laboratory, Inc. */2340 QUIRK_FLAG_DSD_RAW),2341 VENDOR_FLG(0x2d87, /* Cayin device */2342 QUIRK_FLAG_DSD_RAW),2343 VENDOR_FLG(0x3336, /* HEM devices */2344 QUIRK_FLAG_DSD_RAW),2345 VENDOR_FLG(0x3353, /* Khadas devices */2346 QUIRK_FLAG_DSD_RAW),2347 VENDOR_FLG(0x35f4, /* MSB Technology */2348 QUIRK_FLAG_DSD_RAW),2349 VENDOR_FLG(0x3842, /* EVGA */2350 QUIRK_FLAG_DSD_RAW),2351 VENDOR_FLG(0xc502, /* HiBy devices */2352 QUIRK_FLAG_DSD_RAW),2353 2354 {} /* terminator */2355};2356 2357void snd_usb_init_quirk_flags(struct snd_usb_audio *chip)2358{2359 const struct usb_audio_quirk_flags_table *p;2360 2361 for (p = quirk_flags_table; p->id; p++) {2362 if (chip->usb_id == p->id ||2363 (!USB_ID_PRODUCT(p->id) &&2364 USB_ID_VENDOR(chip->usb_id) == USB_ID_VENDOR(p->id))) {2365 usb_audio_dbg(chip,2366 "Set quirk_flags 0x%x for device %04x:%04x\n",2367 p->flags, USB_ID_VENDOR(chip->usb_id),2368 USB_ID_PRODUCT(chip->usb_id));2369 chip->quirk_flags |= p->flags;2370 return;2371 }2372 }2373}2374