source: src/linux/universal/linux-4.9/sound/usb/quirks.c @ 31859

Last change on this file since 31859 was 31859, checked in by brainslayer, 6 weeks ago

kernel update

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