sound/usb/quirks-table.h

0001 /* SPDX-License-Identifier: GPL-2.0-or-later */
0002 /*
0003  * ALSA USB Audio Driver
0004  *
0005  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
0006  *                       Clemens Ladisch <clemens@ladisch.de>
0007  */
0008
0009 /*
0010  * The contents of this file are part of the driver's id_table.
0011  *
0012  * In a perfect world, this file would be empty.
0013  */
0014
0015 /*
0016  * Use this for devices where other interfaces are standard compliant,
0017  * to prevent the quirk being applied to those interfaces. (To work with
0018  * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
0019  */
0020 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
0021     .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
0022                USB_DEVICE_ID_MATCH_PRODUCT | \
0023                USB_DEVICE_ID_MATCH_INT_CLASS, \
0024     .idVendor = vend, \
0025     .idProduct = prod, \
0026     .bInterfaceClass = USB_CLASS_VENDOR_SPEC
0027
0028 /* A standard entry matching with vid/pid and the audio class/subclass */
0029 #define USB_AUDIO_DEVICE(vend, prod) \
0030     .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
0031                USB_DEVICE_ID_MATCH_INT_CLASS | \
0032                USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
0033     .idVendor = vend, \
0034     .idProduct = prod, \
0035     .bInterfaceClass = USB_CLASS_AUDIO, \
0036     .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
0037
0038 /* FTDI devices */
0039 {
0040     USB_DEVICE(0x0403, 0xb8d8),
0041     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0042         /* .vendor_name = "STARR LABS", */
0043         /* .product_name = "Starr Labs MIDI USB device", */
0044         .ifnum = 0,
0045         .type = QUIRK_MIDI_FTDI
0046     }
0047 },
0048
0049 {
0050     /* Creative BT-D1 */
0051     USB_DEVICE(0x041e, 0x0005),
0052     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
0053         .ifnum = 1,
0054         .type = QUIRK_AUDIO_FIXED_ENDPOINT,
0055         .data = &(const struct audioformat) {
0056             .formats = SNDRV_PCM_FMTBIT_S16_LE,
0057             .channels = 2,
0058             .iface = 1,
0059             .altsetting = 1,
0060             .altset_idx = 1,
0061             .endpoint = 0x03,
0062             .ep_attr = USB_ENDPOINT_XFER_ISOC,
0063             .attributes = 0,
0064             .rates = SNDRV_PCM_RATE_CONTINUOUS,
0065             .rate_min = 48000,
0066             .rate_max = 48000,
0067         }
0068     }
0069 },
0070
0071 /* E-Mu 0202 USB */
0072 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f02) },
0073 /* E-Mu 0404 USB */
0074 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f04) },
0075 /* E-Mu Tracker Pre */
0076 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f0a) },
0077 /* E-Mu 0204 USB */
0078 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f19) },
0079
0080 /*
0081  * Creative Technology, Ltd Live! Cam Sync HD [VF0770]
0082  * The device advertises 8 formats, but only a rate of 48kHz is honored by the
0083  * hardware and 24 bits give chopped audio, so only report the one working
0084  * combination.
0085  */
0086 {
0087     USB_AUDIO_DEVICE(0x041e, 0x4095),
0088     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
0089         .ifnum = QUIRK_ANY_INTERFACE,
0090         .type = QUIRK_COMPOSITE,
0091         .data = &(const struct snd_usb_audio_quirk[]) {
0092             {
0093                 .ifnum = 2,
0094                 .type = QUIRK_AUDIO_STANDARD_MIXER,
0095             },
0096             {
0097                 .ifnum = 3,
0098                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
0099                 .data = &(const struct audioformat) {
0100                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
0101                     .channels = 2,
0102                     .fmt_bits = 16,
0103                     .iface = 3,
0104                     .altsetting = 4,
0105                     .altset_idx = 4,
0106                     .endpoint = 0x82,
0107                     .ep_attr = 0x05,
0108                     .rates = SNDRV_PCM_RATE_48000,
0109                     .rate_min = 48000,
0110                     .rate_max = 48000,
0111                     .nr_rates = 1,
0112                     .rate_table = (unsigned int[]) { 48000 },
0113                 },
0114             },
0115             {
0116                 .ifnum = -1
0117             },
0118         },
0119     },
0120 },
0121
0122 /*
0123  * HP Wireless Audio
0124  * When not ignored, causes instability issues for some users, forcing them to
0125  * skip the entire module.
0126  */
0127 {
0128     USB_DEVICE(0x0424, 0xb832),
0129     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
0130         .vendor_name = "Standard Microsystems Corp.",
0131         .product_name = "HP Wireless Audio",
0132         .ifnum = QUIRK_ANY_INTERFACE,
0133         .type = QUIRK_COMPOSITE,
0134         .data = (const struct snd_usb_audio_quirk[]) {
0135             /* Mixer */
0136             {
0137                 .ifnum = 0,
0138                 .type = QUIRK_IGNORE_INTERFACE,
0139             },
0140             /* Playback */
0141             {
0142                 .ifnum = 1,
0143                 .type = QUIRK_IGNORE_INTERFACE,
0144             },
0145             /* Capture */
0146             {
0147                 .ifnum = 2,
0148                 .type = QUIRK_IGNORE_INTERFACE,
0149             },
0150             /* HID Device, .ifnum = 3 */
0151             {
0152                 .ifnum = -1,
0153             }
0154         }
0155     }
0156 },
0157
0158 /*
0159  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
0160  * class matches do not take effect without an explicit ID match.
0161  */
0162 { USB_AUDIO_DEVICE(0x046d, 0x0850) },
0163 { USB_AUDIO_DEVICE(0x046d, 0x08ae) },
0164 { USB_AUDIO_DEVICE(0x046d, 0x08c6) },
0165 { USB_AUDIO_DEVICE(0x046d, 0x08f0) },
0166 { USB_AUDIO_DEVICE(0x046d, 0x08f5) },
0167 { USB_AUDIO_DEVICE(0x046d, 0x08f6) },
0168 { USB_AUDIO_DEVICE(0x046d, 0x0990) },
0169
0170 /*
0171  * Yamaha devices
0172  */
0173
0174 #define YAMAHA_DEVICE(id, name) { \
0175     USB_DEVICE(0x0499, id), \
0176     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
0177         .vendor_name = "Yamaha", \
0178         .product_name = name, \
0179         .ifnum = QUIRK_ANY_INTERFACE, \
0180         .type = QUIRK_MIDI_YAMAHA \
0181     } \
0182 }
0183 #define YAMAHA_INTERFACE(id, intf, name) { \
0184     USB_DEVICE_VENDOR_SPEC(0x0499, id), \
0185     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
0186         .vendor_name = "Yamaha", \
0187         .product_name = name, \
0188         .ifnum = intf, \
0189         .type = QUIRK_MIDI_YAMAHA \
0190     } \
0191 }
0192 YAMAHA_DEVICE(0x1000, "UX256"),
0193 YAMAHA_DEVICE(0x1001, "MU1000"),
0194 YAMAHA_DEVICE(0x1002, "MU2000"),
0195 YAMAHA_DEVICE(0x1003, "MU500"),
0196 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
0197 YAMAHA_DEVICE(0x1005, "MOTIF6"),
0198 YAMAHA_DEVICE(0x1006, "MOTIF7"),
0199 YAMAHA_DEVICE(0x1007, "MOTIF8"),
0200 YAMAHA_DEVICE(0x1008, "UX96"),
0201 YAMAHA_DEVICE(0x1009, "UX16"),
0202 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
0203 YAMAHA_DEVICE(0x100c, "UC-MX"),
0204 YAMAHA_DEVICE(0x100d, "UC-KX"),
0205 YAMAHA_DEVICE(0x100e, "S08"),
0206 YAMAHA_DEVICE(0x100f, "CLP-150"),
0207 YAMAHA_DEVICE(0x1010, "CLP-170"),
0208 YAMAHA_DEVICE(0x1011, "P-250"),
0209 YAMAHA_DEVICE(0x1012, "TYROS"),
0210 YAMAHA_DEVICE(0x1013, "PF-500"),
0211 YAMAHA_DEVICE(0x1014, "S90"),
0212 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
0213 YAMAHA_DEVICE(0x1016, "MDP-5"),
0214 YAMAHA_DEVICE(0x1017, "CVP-204"),
0215 YAMAHA_DEVICE(0x1018, "CVP-206"),
0216 YAMAHA_DEVICE(0x1019, "CVP-208"),
0217 YAMAHA_DEVICE(0x101a, "CVP-210"),
0218 YAMAHA_DEVICE(0x101b, "PSR-1100"),
0219 YAMAHA_DEVICE(0x101c, "PSR-2100"),
0220 YAMAHA_DEVICE(0x101d, "CLP-175"),
0221 YAMAHA_DEVICE(0x101e, "PSR-K1"),
0222 YAMAHA_DEVICE(0x101f, "EZ-J24"),
0223 YAMAHA_DEVICE(0x1020, "EZ-250i"),
0224 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
0225 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
0226 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
0227 YAMAHA_DEVICE(0x1024, "CVP-301"),
0228 YAMAHA_DEVICE(0x1025, "CVP-303"),
0229 YAMAHA_DEVICE(0x1026, "CVP-305"),
0230 YAMAHA_DEVICE(0x1027, "CVP-307"),
0231 YAMAHA_DEVICE(0x1028, "CVP-309"),
0232 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
0233 YAMAHA_DEVICE(0x102a, "PSR-1500"),
0234 YAMAHA_DEVICE(0x102b, "PSR-3000"),
0235 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
0236 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
0237 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
0238 YAMAHA_DEVICE(0x1032, "DGX-305"),
0239 YAMAHA_DEVICE(0x1033, "DGX-505"),
0240 YAMAHA_DEVICE(0x1034, NULL),
0241 YAMAHA_DEVICE(0x1035, NULL),
0242 YAMAHA_DEVICE(0x1036, NULL),
0243 YAMAHA_DEVICE(0x1037, NULL),
0244 YAMAHA_DEVICE(0x1038, NULL),
0245 YAMAHA_DEVICE(0x1039, NULL),
0246 YAMAHA_DEVICE(0x103a, NULL),
0247 YAMAHA_DEVICE(0x103b, NULL),
0248 YAMAHA_DEVICE(0x103c, NULL),
0249 YAMAHA_DEVICE(0x103d, NULL),
0250 YAMAHA_DEVICE(0x103e, NULL),
0251 YAMAHA_DEVICE(0x103f, NULL),
0252 YAMAHA_DEVICE(0x1040, NULL),
0253 YAMAHA_DEVICE(0x1041, NULL),
0254 YAMAHA_DEVICE(0x1042, NULL),
0255 YAMAHA_DEVICE(0x1043, NULL),
0256 YAMAHA_DEVICE(0x1044, NULL),
0257 YAMAHA_DEVICE(0x1045, NULL),
0258 YAMAHA_INTERFACE(0x104e, 0, NULL),
0259 YAMAHA_DEVICE(0x104f, NULL),
0260 YAMAHA_DEVICE(0x1050, NULL),
0261 YAMAHA_DEVICE(0x1051, NULL),
0262 YAMAHA_DEVICE(0x1052, NULL),
0263 YAMAHA_INTERFACE(0x1053, 0, NULL),
0264 YAMAHA_INTERFACE(0x1054, 0, NULL),
0265 YAMAHA_DEVICE(0x1055, NULL),
0266 YAMAHA_DEVICE(0x1056, NULL),
0267 YAMAHA_DEVICE(0x1057, NULL),
0268 YAMAHA_DEVICE(0x1058, NULL),
0269 YAMAHA_DEVICE(0x1059, NULL),
0270 YAMAHA_DEVICE(0x105a, NULL),
0271 YAMAHA_DEVICE(0x105b, NULL),
0272 YAMAHA_DEVICE(0x105c, NULL),
0273 YAMAHA_DEVICE(0x105d, NULL),
0274 {
0275     USB_DEVICE(0x0499, 0x1503),
0276     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0277         /* .vendor_name = "Yamaha", */
0278         /* .product_name = "MOX6/MOX8", */
0279         .ifnum = QUIRK_ANY_INTERFACE,
0280         .type = QUIRK_COMPOSITE,
0281         .data = (const struct snd_usb_audio_quirk[]) {
0282             {
0283                 .ifnum = 1,
0284                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0285             },
0286             {
0287                 .ifnum = 2,
0288                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0289             },
0290             {
0291                 .ifnum = 3,
0292                 .type = QUIRK_MIDI_YAMAHA
0293             },
0294             {
0295                 .ifnum = -1
0296             }
0297         }
0298     }
0299 },
0300 {
0301     USB_DEVICE(0x0499, 0x1507),
0302     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0303         /* .vendor_name = "Yamaha", */
0304         /* .product_name = "THR10", */
0305         .ifnum = QUIRK_ANY_INTERFACE,
0306         .type = QUIRK_COMPOSITE,
0307         .data = (const struct snd_usb_audio_quirk[]) {
0308             {
0309                 .ifnum = 1,
0310                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0311             },
0312             {
0313                 .ifnum = 2,
0314                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0315             },
0316             {
0317                 .ifnum = 3,
0318                 .type = QUIRK_MIDI_YAMAHA
0319             },
0320             {
0321                 .ifnum = -1
0322             }
0323         }
0324     }
0325 },
0326 {
0327     USB_DEVICE(0x0499, 0x1509),
0328     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0329         /* .vendor_name = "Yamaha", */
0330         /* .product_name = "Steinberg UR22", */
0331         .ifnum = QUIRK_ANY_INTERFACE,
0332         .type = QUIRK_COMPOSITE,
0333         .data = (const struct snd_usb_audio_quirk[]) {
0334             {
0335                 .ifnum = 1,
0336                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0337             },
0338             {
0339                 .ifnum = 2,
0340                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0341             },
0342             {
0343                 .ifnum = 3,
0344                 .type = QUIRK_MIDI_YAMAHA
0345             },
0346             {
0347                 .ifnum = 4,
0348                 .type = QUIRK_IGNORE_INTERFACE
0349             },
0350             {
0351                 .ifnum = -1
0352             }
0353         }
0354     }
0355 },
0356 {
0357     USB_DEVICE(0x0499, 0x150a),
0358     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0359         /* .vendor_name = "Yamaha", */
0360         /* .product_name = "THR5A", */
0361         .ifnum = QUIRK_ANY_INTERFACE,
0362         .type = QUIRK_COMPOSITE,
0363         .data = (const struct snd_usb_audio_quirk[]) {
0364             {
0365                 .ifnum = 1,
0366                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0367             },
0368             {
0369                 .ifnum = 2,
0370                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0371             },
0372             {
0373                 .ifnum = 3,
0374                 .type = QUIRK_MIDI_YAMAHA
0375             },
0376             {
0377                 .ifnum = -1
0378             }
0379         }
0380     }
0381 },
0382 {
0383     USB_DEVICE(0x0499, 0x150c),
0384     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0385         /* .vendor_name = "Yamaha", */
0386         /* .product_name = "THR10C", */
0387         .ifnum = QUIRK_ANY_INTERFACE,
0388         .type = QUIRK_COMPOSITE,
0389         .data = (const struct snd_usb_audio_quirk[]) {
0390             {
0391                 .ifnum = 1,
0392                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0393             },
0394             {
0395                 .ifnum = 2,
0396                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0397             },
0398             {
0399                 .ifnum = 3,
0400                 .type = QUIRK_MIDI_YAMAHA
0401             },
0402             {
0403                 .ifnum = -1
0404             }
0405         }
0406     }
0407 },
0408 YAMAHA_DEVICE(0x2000, "DGP-7"),
0409 YAMAHA_DEVICE(0x2001, "DGP-5"),
0410 YAMAHA_DEVICE(0x2002, NULL),
0411 YAMAHA_DEVICE(0x2003, NULL),
0412 YAMAHA_DEVICE(0x5000, "CS1D"),
0413 YAMAHA_DEVICE(0x5001, "DSP1D"),
0414 YAMAHA_DEVICE(0x5002, "DME32"),
0415 YAMAHA_DEVICE(0x5003, "DM2000"),
0416 YAMAHA_DEVICE(0x5004, "02R96"),
0417 YAMAHA_DEVICE(0x5005, "ACU16-C"),
0418 YAMAHA_DEVICE(0x5006, "NHB32-C"),
0419 YAMAHA_DEVICE(0x5007, "DM1000"),
0420 YAMAHA_DEVICE(0x5008, "01V96"),
0421 YAMAHA_DEVICE(0x5009, "SPX2000"),
0422 YAMAHA_DEVICE(0x500a, "PM5D"),
0423 YAMAHA_DEVICE(0x500b, "DME64N"),
0424 YAMAHA_DEVICE(0x500c, "DME24N"),
0425 YAMAHA_DEVICE(0x500d, NULL),
0426 YAMAHA_DEVICE(0x500e, NULL),
0427 YAMAHA_DEVICE(0x500f, NULL),
0428 YAMAHA_DEVICE(0x7000, "DTX"),
0429 YAMAHA_DEVICE(0x7010, "UB99"),
0430 #undef YAMAHA_DEVICE
0431 #undef YAMAHA_INTERFACE
0432 /* this catches most recent vendor-specific Yamaha devices */
0433 {
0434     .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
0435                    USB_DEVICE_ID_MATCH_INT_CLASS,
0436     .idVendor = 0x0499,
0437     .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
0438     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
0439         .ifnum = QUIRK_ANY_INTERFACE,
0440         .type = QUIRK_AUTODETECT
0441     }
0442 },
0443
0444 /*
0445  * Roland/RolandED/Edirol/BOSS devices
0446  */
0447 {
0448     USB_DEVICE(0x0582, 0x0000),
0449     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0450         .vendor_name = "Roland",
0451         .product_name = "UA-100",
0452         .ifnum = QUIRK_ANY_INTERFACE,
0453         .type = QUIRK_COMPOSITE,
0454         .data = (const struct snd_usb_audio_quirk[]) {
0455             {
0456                 .ifnum = 0,
0457                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
0458                 .data = & (const struct audioformat) {
0459                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
0460                     .channels = 4,
0461                     .iface = 0,
0462                     .altsetting = 1,
0463                     .altset_idx = 1,
0464                     .attributes = 0,
0465                     .endpoint = 0x01,
0466                     .ep_attr = 0x09,
0467                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
0468                     .rate_min = 44100,
0469                     .rate_max = 44100,
0470                 }
0471             },
0472             {
0473                 .ifnum = 1,
0474                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
0475                 .data = & (const struct audioformat) {
0476                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
0477                     .channels = 2,
0478                     .iface = 1,
0479                     .altsetting = 1,
0480                     .altset_idx = 1,
0481                     .attributes = UAC_EP_CS_ATTR_FILL_MAX,
0482                     .endpoint = 0x81,
0483                     .ep_attr = 0x05,
0484                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
0485                     .rate_min = 44100,
0486                     .rate_max = 44100,
0487                 }
0488             },
0489             {
0490                 .ifnum = 2,
0491                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0492                 .data = & (const struct snd_usb_midi_endpoint_info) {
0493                     .out_cables = 0x0007,
0494                     .in_cables  = 0x0007
0495                 }
0496             },
0497             {
0498                 .ifnum = -1
0499             }
0500         }
0501     }
0502 },
0503 {
0504     USB_DEVICE(0x0582, 0x0002),
0505     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0506         .vendor_name = "EDIROL",
0507         .product_name = "UM-4",
0508         .ifnum = QUIRK_ANY_INTERFACE,
0509         .type = QUIRK_COMPOSITE,
0510         .data = (const struct snd_usb_audio_quirk[]) {
0511             {
0512                 .ifnum = 0,
0513                 .type = QUIRK_IGNORE_INTERFACE
0514             },
0515             {
0516                 .ifnum = 1,
0517                 .type = QUIRK_IGNORE_INTERFACE
0518             },
0519             {
0520                 .ifnum = 2,
0521                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0522                 .data = & (const struct snd_usb_midi_endpoint_info) {
0523                     .out_cables = 0x000f,
0524                     .in_cables  = 0x000f
0525                 }
0526             },
0527             {
0528                 .ifnum = -1
0529             }
0530         }
0531     }
0532 },
0533 {
0534     USB_DEVICE(0x0582, 0x0003),
0535     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0536         .vendor_name = "Roland",
0537         .product_name = "SC-8850",
0538         .ifnum = QUIRK_ANY_INTERFACE,
0539         .type = QUIRK_COMPOSITE,
0540         .data = (const struct snd_usb_audio_quirk[]) {
0541             {
0542                 .ifnum = 0,
0543                 .type = QUIRK_IGNORE_INTERFACE
0544             },
0545             {
0546                 .ifnum = 1,
0547                 .type = QUIRK_IGNORE_INTERFACE
0548             },
0549             {
0550                 .ifnum = 2,
0551                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0552                 .data = & (const struct snd_usb_midi_endpoint_info) {
0553                     .out_cables = 0x003f,
0554                     .in_cables  = 0x003f
0555                 }
0556             },
0557             {
0558                 .ifnum = -1
0559             }
0560         }
0561     }
0562 },
0563 {
0564     USB_DEVICE(0x0582, 0x0004),
0565     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0566         .vendor_name = "Roland",
0567         .product_name = "U-8",
0568         .ifnum = QUIRK_ANY_INTERFACE,
0569         .type = QUIRK_COMPOSITE,
0570         .data = (const struct snd_usb_audio_quirk[]) {
0571             {
0572                 .ifnum = 0,
0573                 .type = QUIRK_IGNORE_INTERFACE
0574             },
0575             {
0576                 .ifnum = 1,
0577                 .type = QUIRK_IGNORE_INTERFACE
0578             },
0579             {
0580                 .ifnum = 2,
0581                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0582                 .data = & (const struct snd_usb_midi_endpoint_info) {
0583                     .out_cables = 0x0005,
0584                     .in_cables  = 0x0005
0585                 }
0586             },
0587             {
0588                 .ifnum = -1
0589             }
0590         }
0591     }
0592 },
0593 {
0594     /* Has ID 0x0099 when not in "Advanced Driver" mode.
0595      * The UM-2EX has only one input, but we cannot detect this. */
0596     USB_DEVICE(0x0582, 0x0005),
0597     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0598         .vendor_name = "EDIROL",
0599         .product_name = "UM-2",
0600         .ifnum = QUIRK_ANY_INTERFACE,
0601         .type = QUIRK_COMPOSITE,
0602         .data = (const struct snd_usb_audio_quirk[]) {
0603             {
0604                 .ifnum = 0,
0605                 .type = QUIRK_IGNORE_INTERFACE
0606             },
0607             {
0608                 .ifnum = 1,
0609                 .type = QUIRK_IGNORE_INTERFACE
0610             },
0611             {
0612                 .ifnum = 2,
0613                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0614                 .data = & (const struct snd_usb_midi_endpoint_info) {
0615                     .out_cables = 0x0003,
0616                     .in_cables  = 0x0003
0617                 }
0618             },
0619             {
0620                 .ifnum = -1
0621             }
0622         }
0623     }
0624 },
0625 {
0626     USB_DEVICE(0x0582, 0x0007),
0627     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0628         .vendor_name = "Roland",
0629         .product_name = "SC-8820",
0630         .ifnum = QUIRK_ANY_INTERFACE,
0631         .type = QUIRK_COMPOSITE,
0632         .data = (const struct snd_usb_audio_quirk[]) {
0633             {
0634                 .ifnum = 0,
0635                 .type = QUIRK_IGNORE_INTERFACE
0636             },
0637             {
0638                 .ifnum = 1,
0639                 .type = QUIRK_IGNORE_INTERFACE
0640             },
0641             {
0642                 .ifnum = 2,
0643                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0644                 .data = & (const struct snd_usb_midi_endpoint_info) {
0645                     .out_cables = 0x0013,
0646                     .in_cables  = 0x0013
0647                 }
0648             },
0649             {
0650                 .ifnum = -1
0651             }
0652         }
0653     }
0654 },
0655 {
0656     USB_DEVICE(0x0582, 0x0008),
0657     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0658         .vendor_name = "Roland",
0659         .product_name = "PC-300",
0660         .ifnum = QUIRK_ANY_INTERFACE,
0661         .type = QUIRK_COMPOSITE,
0662         .data = (const struct snd_usb_audio_quirk[]) {
0663             {
0664                 .ifnum = 0,
0665                 .type = QUIRK_IGNORE_INTERFACE
0666             },
0667             {
0668                 .ifnum = 1,
0669                 .type = QUIRK_IGNORE_INTERFACE
0670             },
0671             {
0672                 .ifnum = 2,
0673                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0674                 .data = & (const struct snd_usb_midi_endpoint_info) {
0675                     .out_cables = 0x0001,
0676                     .in_cables  = 0x0001
0677                 }
0678             },
0679             {
0680                 .ifnum = -1
0681             }
0682         }
0683     }
0684 },
0685 {
0686     /* has ID 0x009d when not in "Advanced Driver" mode */
0687     USB_DEVICE(0x0582, 0x0009),
0688     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0689         .vendor_name = "EDIROL",
0690         .product_name = "UM-1",
0691         .ifnum = QUIRK_ANY_INTERFACE,
0692         .type = QUIRK_COMPOSITE,
0693         .data = (const struct snd_usb_audio_quirk[]) {
0694             {
0695                 .ifnum = 0,
0696                 .type = QUIRK_IGNORE_INTERFACE
0697             },
0698             {
0699                 .ifnum = 1,
0700                 .type = QUIRK_IGNORE_INTERFACE
0701             },
0702             {
0703                 .ifnum = 2,
0704                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0705                 .data = & (const struct snd_usb_midi_endpoint_info) {
0706                     .out_cables = 0x0001,
0707                     .in_cables  = 0x0001
0708                 }
0709             },
0710             {
0711                 .ifnum = -1
0712             }
0713         }
0714     }
0715 },
0716 {
0717     USB_DEVICE(0x0582, 0x000b),
0718     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0719         .vendor_name = "Roland",
0720         .product_name = "SK-500",
0721         .ifnum = QUIRK_ANY_INTERFACE,
0722         .type = QUIRK_COMPOSITE,
0723         .data = (const struct snd_usb_audio_quirk[]) {
0724             {
0725                 .ifnum = 0,
0726                 .type = QUIRK_IGNORE_INTERFACE
0727             },
0728             {
0729                 .ifnum = 1,
0730                 .type = QUIRK_IGNORE_INTERFACE
0731             },
0732             {
0733                 .ifnum = 2,
0734                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0735                 .data = & (const struct snd_usb_midi_endpoint_info) {
0736                     .out_cables = 0x0013,
0737                     .in_cables  = 0x0013
0738                 }
0739             },
0740             {
0741                 .ifnum = -1
0742             }
0743         }
0744     }
0745 },
0746 {
0747     /* thanks to Emiliano Grilli <emillo@libero.it>
0748      * for helping researching this data */
0749     USB_DEVICE(0x0582, 0x000c),
0750     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0751         .vendor_name = "Roland",
0752         .product_name = "SC-D70",
0753         .ifnum = QUIRK_ANY_INTERFACE,
0754         .type = QUIRK_COMPOSITE,
0755         .data = (const struct snd_usb_audio_quirk[]) {
0756             {
0757                 .ifnum = 0,
0758                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0759             },
0760             {
0761                 .ifnum = 1,
0762                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0763             },
0764             {
0765                 .ifnum = 2,
0766                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0767                 .data = & (const struct snd_usb_midi_endpoint_info) {
0768                     .out_cables = 0x0007,
0769                     .in_cables  = 0x0007
0770                 }
0771             },
0772             {
0773                 .ifnum = -1
0774             }
0775         }
0776     }
0777 },
0778 {   /*
0779      * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
0780      * If the advanced mode switch at the back of the unit is off, the
0781      * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
0782      * but offers only 16-bit PCM.
0783      * In advanced mode, the UA-5 will output S24_3LE samples (two
0784      * channels) at the rate indicated on the front switch, including
0785      * the 96kHz sample rate.
0786      */
0787     USB_DEVICE(0x0582, 0x0010),
0788     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0789         .vendor_name = "EDIROL",
0790         .product_name = "UA-5",
0791         .ifnum = QUIRK_ANY_INTERFACE,
0792         .type = QUIRK_COMPOSITE,
0793         .data = (const struct snd_usb_audio_quirk[]) {
0794             {
0795                 .ifnum = 1,
0796                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0797             },
0798             {
0799                 .ifnum = 2,
0800                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0801             },
0802             {
0803                 .ifnum = -1
0804             }
0805         }
0806     }
0807 },
0808 {
0809     /* has ID 0x0013 when not in "Advanced Driver" mode */
0810     USB_DEVICE(0x0582, 0x0012),
0811     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0812         .vendor_name = "Roland",
0813         .product_name = "XV-5050",
0814         .ifnum = 0,
0815         .type = QUIRK_MIDI_FIXED_ENDPOINT,
0816         .data = & (const struct snd_usb_midi_endpoint_info) {
0817             .out_cables = 0x0001,
0818             .in_cables  = 0x0001
0819         }
0820     }
0821 },
0822 {
0823     /* has ID 0x0015 when not in "Advanced Driver" mode */
0824     USB_DEVICE(0x0582, 0x0014),
0825     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0826         .vendor_name = "EDIROL",
0827         .product_name = "UM-880",
0828         .ifnum = 0,
0829         .type = QUIRK_MIDI_FIXED_ENDPOINT,
0830         .data = & (const struct snd_usb_midi_endpoint_info) {
0831             .out_cables = 0x01ff,
0832             .in_cables  = 0x01ff
0833         }
0834     }
0835 },
0836 {
0837     /* has ID 0x0017 when not in "Advanced Driver" mode */
0838     USB_DEVICE(0x0582, 0x0016),
0839     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0840         .vendor_name = "EDIROL",
0841         .product_name = "SD-90",
0842         .ifnum = QUIRK_ANY_INTERFACE,
0843         .type = QUIRK_COMPOSITE,
0844         .data = (const struct snd_usb_audio_quirk[]) {
0845             {
0846                 .ifnum = 0,
0847                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0848             },
0849             {
0850                 .ifnum = 1,
0851                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
0852             },
0853             {
0854                 .ifnum = 2,
0855                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0856                 .data = & (const struct snd_usb_midi_endpoint_info) {
0857                     .out_cables = 0x000f,
0858                     .in_cables  = 0x000f
0859                 }
0860             },
0861             {
0862                 .ifnum = -1
0863             }
0864         }
0865     }
0866 },
0867 {
0868     /* has ID 0x001c when not in "Advanced Driver" mode */
0869     USB_DEVICE(0x0582, 0x001b),
0870     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0871         .vendor_name = "Roland",
0872         .product_name = "MMP-2",
0873         .ifnum = QUIRK_ANY_INTERFACE,
0874         .type = QUIRK_COMPOSITE,
0875         .data = (const struct snd_usb_audio_quirk[]) {
0876             {
0877                 .ifnum = 0,
0878                 .type = QUIRK_IGNORE_INTERFACE
0879             },
0880             {
0881                 .ifnum = 1,
0882                 .type = QUIRK_IGNORE_INTERFACE
0883             },
0884             {
0885                 .ifnum = 2,
0886                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0887                 .data = & (const struct snd_usb_midi_endpoint_info) {
0888                     .out_cables = 0x0001,
0889                     .in_cables  = 0x0001
0890                 }
0891             },
0892             {
0893                 .ifnum = -1
0894             }
0895         }
0896     }
0897 },
0898 {
0899     /* has ID 0x001e when not in "Advanced Driver" mode */
0900     USB_DEVICE(0x0582, 0x001d),
0901     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0902         .vendor_name = "Roland",
0903         .product_name = "V-SYNTH",
0904         .ifnum = 0,
0905         .type = QUIRK_MIDI_FIXED_ENDPOINT,
0906         .data = & (const struct snd_usb_midi_endpoint_info) {
0907             .out_cables = 0x0001,
0908             .in_cables  = 0x0001
0909         }
0910     }
0911 },
0912 {
0913     /* has ID 0x0024 when not in "Advanced Driver" mode */
0914     USB_DEVICE(0x0582, 0x0023),
0915     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0916         .vendor_name = "EDIROL",
0917         .product_name = "UM-550",
0918         .ifnum = 0,
0919         .type = QUIRK_MIDI_FIXED_ENDPOINT,
0920         .data = & (const struct snd_usb_midi_endpoint_info) {
0921             .out_cables = 0x003f,
0922             .in_cables  = 0x003f
0923         }
0924     }
0925 },
0926 {
0927     /*
0928      * This quirk is for the "Advanced Driver" mode. If off, the UA-20
0929      * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
0930      * and no MIDI.
0931      */
0932     USB_DEVICE(0x0582, 0x0025),
0933     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0934         .vendor_name = "EDIROL",
0935         .product_name = "UA-20",
0936         .ifnum = QUIRK_ANY_INTERFACE,
0937         .type = QUIRK_COMPOSITE,
0938         .data = (const struct snd_usb_audio_quirk[]) {
0939             {
0940                 .ifnum = 0,
0941                 .type = QUIRK_IGNORE_INTERFACE
0942             },
0943             {
0944                 .ifnum = 1,
0945                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
0946                 .data = & (const struct audioformat) {
0947                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
0948                     .channels = 2,
0949                     .iface = 1,
0950                     .altsetting = 1,
0951                     .altset_idx = 1,
0952                     .attributes = 0,
0953                     .endpoint = 0x01,
0954                     .ep_attr = 0x01,
0955                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
0956                     .rate_min = 44100,
0957                     .rate_max = 44100,
0958                 }
0959             },
0960             {
0961                 .ifnum = 2,
0962                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
0963                 .data = & (const struct audioformat) {
0964                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
0965                     .channels = 2,
0966                     .iface = 2,
0967                     .altsetting = 1,
0968                     .altset_idx = 1,
0969                     .attributes = 0,
0970                     .endpoint = 0x82,
0971                     .ep_attr = 0x01,
0972                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
0973                     .rate_min = 44100,
0974                     .rate_max = 44100,
0975                 }
0976             },
0977             {
0978                 .ifnum = 3,
0979                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
0980                 .data = & (const struct snd_usb_midi_endpoint_info) {
0981                     .out_cables = 0x0001,
0982                     .in_cables  = 0x0001
0983                 }
0984             },
0985             {
0986                 .ifnum = -1
0987             }
0988         }
0989     }
0990 },
0991 {
0992     /* has ID 0x0028 when not in "Advanced Driver" mode */
0993     USB_DEVICE(0x0582, 0x0027),
0994     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
0995         .vendor_name = "EDIROL",
0996         .product_name = "SD-20",
0997         .ifnum = 0,
0998         .type = QUIRK_MIDI_FIXED_ENDPOINT,
0999         .data = & (const struct snd_usb_midi_endpoint_info) {
1000             .out_cables = 0x0003,
1001             .in_cables  = 0x0007
1002         }
1003     }
1004 },
1005 {
1006     /* has ID 0x002a when not in "Advanced Driver" mode */
1007     USB_DEVICE(0x0582, 0x0029),
1008     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1009         .vendor_name = "EDIROL",
1010         .product_name = "SD-80",
1011         .ifnum = 0,
1012         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1013         .data = & (const struct snd_usb_midi_endpoint_info) {
1014             .out_cables = 0x000f,
1015             .in_cables  = 0x000f
1016         }
1017     }
1018 },
1019 {   /*
1020      * This quirk is for the "Advanced" modes of the Edirol UA-700.
1021      * If the sample format switch is not in an advanced setting, the
1022      * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
1023      * but offers only 16-bit PCM and no MIDI.
1024      */
1025     USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
1026     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1027         .vendor_name = "EDIROL",
1028         .product_name = "UA-700",
1029         .ifnum = QUIRK_ANY_INTERFACE,
1030         .type = QUIRK_COMPOSITE,
1031         .data = (const struct snd_usb_audio_quirk[]) {
1032             {
1033                 .ifnum = 1,
1034                 .type = QUIRK_AUDIO_EDIROL_UAXX
1035             },
1036             {
1037                 .ifnum = 2,
1038                 .type = QUIRK_AUDIO_EDIROL_UAXX
1039             },
1040             {
1041                 .ifnum = 3,
1042                 .type = QUIRK_AUDIO_EDIROL_UAXX
1043             },
1044             {
1045                 .ifnum = -1
1046             }
1047         }
1048     }
1049 },
1050 {
1051     /* has ID 0x002e when not in "Advanced Driver" mode */
1052     USB_DEVICE(0x0582, 0x002d),
1053     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1054         .vendor_name = "Roland",
1055         .product_name = "XV-2020",
1056         .ifnum = 0,
1057         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1058         .data = & (const struct snd_usb_midi_endpoint_info) {
1059             .out_cables = 0x0001,
1060             .in_cables  = 0x0001
1061         }
1062     }
1063 },
1064 {
1065     /* has ID 0x0030 when not in "Advanced Driver" mode */
1066     USB_DEVICE(0x0582, 0x002f),
1067     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1068         .vendor_name = "Roland",
1069         .product_name = "VariOS",
1070         .ifnum = 0,
1071         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1072         .data = & (const struct snd_usb_midi_endpoint_info) {
1073             .out_cables = 0x0007,
1074             .in_cables  = 0x0007
1075         }
1076     }
1077 },
1078 {
1079     /* has ID 0x0034 when not in "Advanced Driver" mode */
1080     USB_DEVICE(0x0582, 0x0033),
1081     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1082         .vendor_name = "EDIROL",
1083         .product_name = "PCR",
1084         .ifnum = 0,
1085         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1086         .data = & (const struct snd_usb_midi_endpoint_info) {
1087             .out_cables = 0x0003,
1088             .in_cables  = 0x0007
1089         }
1090     }
1091 },
1092 {
1093     /*
1094      * Has ID 0x0038 when not in "Advanced Driver" mode;
1095      * later revisions use IDs 0x0054 and 0x00a2.
1096      */
1097     USB_DEVICE(0x0582, 0x0037),
1098     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1099         .vendor_name = "Roland",
1100         .product_name = "Digital Piano",
1101         .ifnum = 0,
1102         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1103         .data = & (const struct snd_usb_midi_endpoint_info) {
1104             .out_cables = 0x0001,
1105             .in_cables  = 0x0001
1106         }
1107     }
1108 },
1109 {
1110     /*
1111      * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1112      * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1113      * and no MIDI.
1114      */
1115     USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1116     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117         .vendor_name = "BOSS",
1118         .product_name = "GS-10",
1119         .ifnum = QUIRK_ANY_INTERFACE,
1120         .type = QUIRK_COMPOSITE,
1121         .data = & (const struct snd_usb_audio_quirk[]) {
1122             {
1123                 .ifnum = 1,
1124                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1125             },
1126             {
1127                 .ifnum = 2,
1128                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1129             },
1130             {
1131                 .ifnum = 3,
1132                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1133             },
1134             {
1135                 .ifnum = -1
1136             }
1137         }
1138     }
1139 },
1140 {
1141     /* has ID 0x0041 when not in "Advanced Driver" mode */
1142     USB_DEVICE(0x0582, 0x0040),
1143     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1144         .vendor_name = "Roland",
1145         .product_name = "GI-20",
1146         .ifnum = 0,
1147         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1148         .data = & (const struct snd_usb_midi_endpoint_info) {
1149             .out_cables = 0x0001,
1150             .in_cables  = 0x0001
1151         }
1152     }
1153 },
1154 {
1155     /* has ID 0x0043 when not in "Advanced Driver" mode */
1156     USB_DEVICE(0x0582, 0x0042),
1157     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1158         .vendor_name = "Roland",
1159         .product_name = "RS-70",
1160         .ifnum = 0,
1161         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1162         .data = & (const struct snd_usb_midi_endpoint_info) {
1163             .out_cables = 0x0001,
1164             .in_cables  = 0x0001
1165         }
1166     }
1167 },
1168 {
1169     /* has ID 0x0049 when not in "Advanced Driver" mode */
1170     USB_DEVICE(0x0582, 0x0047),
1171     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1172         /* .vendor_name = "EDIROL", */
1173         /* .product_name = "UR-80", */
1174         .ifnum = QUIRK_ANY_INTERFACE,
1175         .type = QUIRK_COMPOSITE,
1176         .data = (const struct snd_usb_audio_quirk[]) {
1177             /* in the 96 kHz modes, only interface 1 is there */
1178             {
1179                 .ifnum = 1,
1180                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1181             },
1182             {
1183                 .ifnum = 2,
1184                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1185             },
1186             {
1187                 .ifnum = -1
1188             }
1189         }
1190     }
1191 },
1192 {
1193     /* has ID 0x004a when not in "Advanced Driver" mode */
1194     USB_DEVICE(0x0582, 0x0048),
1195     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1196         /* .vendor_name = "EDIROL", */
1197         /* .product_name = "UR-80", */
1198         .ifnum = 0,
1199         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1200         .data = & (const struct snd_usb_midi_endpoint_info) {
1201             .out_cables = 0x0003,
1202             .in_cables  = 0x0007
1203         }
1204     }
1205 },
1206 {
1207     /* has ID 0x004e when not in "Advanced Driver" mode */
1208     USB_DEVICE(0x0582, 0x004c),
1209     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1210         .vendor_name = "EDIROL",
1211         .product_name = "PCR-A",
1212         .ifnum = QUIRK_ANY_INTERFACE,
1213         .type = QUIRK_COMPOSITE,
1214         .data = (const struct snd_usb_audio_quirk[]) {
1215             {
1216                 .ifnum = 1,
1217                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1218             },
1219             {
1220                 .ifnum = 2,
1221                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1222             },
1223             {
1224                 .ifnum = -1
1225             }
1226         }
1227     }
1228 },
1229 {
1230     /* has ID 0x004f when not in "Advanced Driver" mode */
1231     USB_DEVICE(0x0582, 0x004d),
1232     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1233         .vendor_name = "EDIROL",
1234         .product_name = "PCR-A",
1235         .ifnum = 0,
1236         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1237         .data = & (const struct snd_usb_midi_endpoint_info) {
1238             .out_cables = 0x0003,
1239             .in_cables  = 0x0007
1240         }
1241     }
1242 },
1243 {
1244     /*
1245      * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1246      * is standard compliant, but has only 16-bit PCM.
1247      */
1248     USB_DEVICE(0x0582, 0x0050),
1249     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1250         .vendor_name = "EDIROL",
1251         .product_name = "UA-3FX",
1252         .ifnum = QUIRK_ANY_INTERFACE,
1253         .type = QUIRK_COMPOSITE,
1254         .data = (const struct snd_usb_audio_quirk[]) {
1255             {
1256                 .ifnum = 1,
1257                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1258             },
1259             {
1260                 .ifnum = 2,
1261                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1262             },
1263             {
1264                 .ifnum = -1
1265             }
1266         }
1267     }
1268 },
1269 {
1270     USB_DEVICE(0x0582, 0x0052),
1271     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1272         .vendor_name = "EDIROL",
1273         .product_name = "UM-1SX",
1274         .ifnum = 0,
1275         .type = QUIRK_MIDI_STANDARD_INTERFACE
1276     }
1277 },
1278 {
1279     USB_DEVICE(0x0582, 0x0060),
1280     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1281         .vendor_name = "Roland",
1282         .product_name = "EXR Series",
1283         .ifnum = 0,
1284         .type = QUIRK_MIDI_STANDARD_INTERFACE
1285     }
1286 },
1287 {
1288     /* has ID 0x0066 when not in "Advanced Driver" mode */
1289     USB_DEVICE(0x0582, 0x0064),
1290     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1291         /* .vendor_name = "EDIROL", */
1292         /* .product_name = "PCR-1", */
1293         .ifnum = QUIRK_ANY_INTERFACE,
1294         .type = QUIRK_COMPOSITE,
1295         .data = (const struct snd_usb_audio_quirk[]) {
1296             {
1297                 .ifnum = 1,
1298                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1299             },
1300             {
1301                 .ifnum = 2,
1302                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1303             },
1304             {
1305                 .ifnum = -1
1306             }
1307         }
1308     }
1309 },
1310 {
1311     /* has ID 0x0067 when not in "Advanced Driver" mode */
1312     USB_DEVICE(0x0582, 0x0065),
1313     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1314         /* .vendor_name = "EDIROL", */
1315         /* .product_name = "PCR-1", */
1316         .ifnum = 0,
1317         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1318         .data = & (const struct snd_usb_midi_endpoint_info) {
1319             .out_cables = 0x0001,
1320             .in_cables  = 0x0003
1321         }
1322     }
1323 },
1324 {
1325     /* has ID 0x006e when not in "Advanced Driver" mode */
1326     USB_DEVICE(0x0582, 0x006d),
1327     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1328         .vendor_name = "Roland",
1329         .product_name = "FANTOM-X",
1330         .ifnum = 0,
1331         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1332         .data = & (const struct snd_usb_midi_endpoint_info) {
1333             .out_cables = 0x0001,
1334             .in_cables  = 0x0001
1335         }
1336     }
1337 },
1338 {   /*
1339      * This quirk is for the "Advanced" modes of the Edirol UA-25.
1340      * If the switch is not in an advanced setting, the UA-25 has
1341      * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1342      * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1343      */
1344     USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1345     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1346         .vendor_name = "EDIROL",
1347         .product_name = "UA-25",
1348         .ifnum = QUIRK_ANY_INTERFACE,
1349         .type = QUIRK_COMPOSITE,
1350         .data = (const struct snd_usb_audio_quirk[]) {
1351             {
1352                 .ifnum = 0,
1353                 .type = QUIRK_AUDIO_EDIROL_UAXX
1354             },
1355             {
1356                 .ifnum = 1,
1357                 .type = QUIRK_AUDIO_EDIROL_UAXX
1358             },
1359             {
1360                 .ifnum = 2,
1361                 .type = QUIRK_AUDIO_EDIROL_UAXX
1362             },
1363             {
1364                 .ifnum = -1
1365             }
1366         }
1367     }
1368 },
1369 {
1370     /* has ID 0x0076 when not in "Advanced Driver" mode */
1371     USB_DEVICE(0x0582, 0x0075),
1372     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1373         .vendor_name = "BOSS",
1374         .product_name = "DR-880",
1375         .ifnum = 0,
1376         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1377         .data = & (const struct snd_usb_midi_endpoint_info) {
1378             .out_cables = 0x0001,
1379             .in_cables  = 0x0001
1380         }
1381     }
1382 },
1383 {
1384     /* has ID 0x007b when not in "Advanced Driver" mode */
1385     USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1386     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1387         .vendor_name = "Roland",
1388         /* "RD" or "RD-700SX"? */
1389         .ifnum = 0,
1390         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1391         .data = & (const struct snd_usb_midi_endpoint_info) {
1392             .out_cables = 0x0003,
1393             .in_cables  = 0x0003
1394         }
1395     }
1396 },
1397 {
1398     /* has ID 0x0081 when not in "Advanced Driver" mode */
1399     USB_DEVICE(0x0582, 0x0080),
1400     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1401         .vendor_name = "Roland",
1402         .product_name = "G-70",
1403         .ifnum = 0,
1404         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1405         .data = & (const struct snd_usb_midi_endpoint_info) {
1406             .out_cables = 0x0001,
1407             .in_cables  = 0x0001
1408         }
1409     }
1410 },
1411 {
1412     /* has ID 0x008c when not in "Advanced Driver" mode */
1413     USB_DEVICE(0x0582, 0x008b),
1414     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1415         .vendor_name = "EDIROL",
1416         .product_name = "PC-50",
1417         .ifnum = 0,
1418         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1419         .data = & (const struct snd_usb_midi_endpoint_info) {
1420             .out_cables = 0x0001,
1421             .in_cables  = 0x0001
1422         }
1423     }
1424 },
1425 {
1426     /*
1427      * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1428      * is standard compliant, but has only 16-bit PCM and no MIDI.
1429      */
1430     USB_DEVICE(0x0582, 0x00a3),
1431     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432         .vendor_name = "EDIROL",
1433         .product_name = "UA-4FX",
1434         .ifnum = QUIRK_ANY_INTERFACE,
1435         .type = QUIRK_COMPOSITE,
1436         .data = (const struct snd_usb_audio_quirk[]) {
1437             {
1438                 .ifnum = 0,
1439                 .type = QUIRK_AUDIO_EDIROL_UAXX
1440             },
1441             {
1442                 .ifnum = 1,
1443                 .type = QUIRK_AUDIO_EDIROL_UAXX
1444             },
1445             {
1446                 .ifnum = 2,
1447                 .type = QUIRK_AUDIO_EDIROL_UAXX
1448             },
1449             {
1450                 .ifnum = -1
1451             }
1452         }
1453     }
1454 },
1455 {
1456     /* Edirol M-16DX */
1457     USB_DEVICE(0x0582, 0x00c4),
1458     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1459         .ifnum = QUIRK_ANY_INTERFACE,
1460         .type = QUIRK_COMPOSITE,
1461         .data = (const struct snd_usb_audio_quirk[]) {
1462             {
1463                 .ifnum = 0,
1464                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1465             },
1466             {
1467                 .ifnum = 1,
1468                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1469             },
1470             {
1471                 .ifnum = 2,
1472                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1473                 .data = & (const struct snd_usb_midi_endpoint_info) {
1474                     .out_cables = 0x0001,
1475                     .in_cables  = 0x0001
1476                 }
1477             },
1478             {
1479                 .ifnum = -1
1480             }
1481         }
1482     }
1483 },
1484 {
1485     /* Advanced modes of the Edirol UA-25EX.
1486      * For the standard mode, UA-25EX has ID 0582:00e7, which
1487      * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1488      */
1489     USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1490     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1491         .vendor_name = "EDIROL",
1492         .product_name = "UA-25EX",
1493         .ifnum = QUIRK_ANY_INTERFACE,
1494         .type = QUIRK_COMPOSITE,
1495         .data = (const struct snd_usb_audio_quirk[]) {
1496             {
1497                 .ifnum = 0,
1498                 .type = QUIRK_AUDIO_EDIROL_UAXX
1499             },
1500             {
1501                 .ifnum = 1,
1502                 .type = QUIRK_AUDIO_EDIROL_UAXX
1503             },
1504             {
1505                 .ifnum = 2,
1506                 .type = QUIRK_AUDIO_EDIROL_UAXX
1507             },
1508             {
1509                 .ifnum = -1
1510             }
1511         }
1512     }
1513 },
1514 {
1515     /* Edirol UM-3G */
1516     USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1517     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1518         .ifnum = 0,
1519         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1520         .data = & (const struct snd_usb_midi_endpoint_info) {
1521             .out_cables = 0x0007,
1522             .in_cables  = 0x0007
1523         }
1524     }
1525 },
1526 {
1527     /* BOSS ME-25 */
1528     USB_DEVICE(0x0582, 0x0113),
1529     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1530         .ifnum = QUIRK_ANY_INTERFACE,
1531         .type = QUIRK_COMPOSITE,
1532         .data = (const struct snd_usb_audio_quirk[]) {
1533             {
1534                 .ifnum = 0,
1535                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1536             },
1537             {
1538                 .ifnum = 1,
1539                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1540             },
1541             {
1542                 .ifnum = 2,
1543                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1544                 .data = & (const struct snd_usb_midi_endpoint_info) {
1545                     .out_cables = 0x0001,
1546                     .in_cables  = 0x0001
1547                 }
1548             },
1549             {
1550                 .ifnum = -1
1551             }
1552         }
1553     }
1554 },
1555 {
1556     /* only 44.1 kHz works at the moment */
1557     USB_DEVICE(0x0582, 0x0120),
1558     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1559         /* .vendor_name = "Roland", */
1560         /* .product_name = "OCTO-CAPTURE", */
1561         .ifnum = QUIRK_ANY_INTERFACE,
1562         .type = QUIRK_COMPOSITE,
1563         .data = (const struct snd_usb_audio_quirk[]) {
1564             {
1565                 .ifnum = 0,
1566                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1567                 .data = & (const struct audioformat) {
1568                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
1569                     .channels = 10,
1570                     .iface = 0,
1571                     .altsetting = 1,
1572                     .altset_idx = 1,
1573                     .endpoint = 0x05,
1574                     .ep_attr = 0x05,
1575                     .rates = SNDRV_PCM_RATE_44100,
1576                     .rate_min = 44100,
1577                     .rate_max = 44100,
1578                     .nr_rates = 1,
1579                     .rate_table = (unsigned int[]) { 44100 }
1580                 }
1581             },
1582             {
1583                 .ifnum = 1,
1584                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1585                 .data = & (const struct audioformat) {
1586                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
1587                     .channels = 12,
1588                     .iface = 1,
1589                     .altsetting = 1,
1590                     .altset_idx = 1,
1591                     .endpoint = 0x85,
1592                     .ep_attr = 0x25,
1593                     .rates = SNDRV_PCM_RATE_44100,
1594                     .rate_min = 44100,
1595                     .rate_max = 44100,
1596                     .nr_rates = 1,
1597                     .rate_table = (unsigned int[]) { 44100 }
1598                 }
1599             },
1600             {
1601                 .ifnum = 2,
1602                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1603                 .data = & (const struct snd_usb_midi_endpoint_info) {
1604                     .out_cables = 0x0001,
1605                     .in_cables  = 0x0001
1606                 }
1607             },
1608             {
1609                 .ifnum = 3,
1610                 .type = QUIRK_IGNORE_INTERFACE
1611             },
1612             {
1613                 .ifnum = 4,
1614                 .type = QUIRK_IGNORE_INTERFACE
1615             },
1616             {
1617                 .ifnum = -1
1618             }
1619         }
1620     }
1621 },
1622 {
1623     /* only 44.1 kHz works at the moment */
1624     USB_DEVICE(0x0582, 0x012f),
1625     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1626         /* .vendor_name = "Roland", */
1627         /* .product_name = "QUAD-CAPTURE", */
1628         .ifnum = QUIRK_ANY_INTERFACE,
1629         .type = QUIRK_COMPOSITE,
1630         .data = (const struct snd_usb_audio_quirk[]) {
1631             {
1632                 .ifnum = 0,
1633                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1634                 .data = & (const struct audioformat) {
1635                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
1636                     .channels = 4,
1637                     .iface = 0,
1638                     .altsetting = 1,
1639                     .altset_idx = 1,
1640                     .endpoint = 0x05,
1641                     .ep_attr = 0x05,
1642                     .rates = SNDRV_PCM_RATE_44100,
1643                     .rate_min = 44100,
1644                     .rate_max = 44100,
1645                     .nr_rates = 1,
1646                     .rate_table = (unsigned int[]) { 44100 }
1647                 }
1648             },
1649             {
1650                 .ifnum = 1,
1651                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
1652                 .data = & (const struct audioformat) {
1653                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
1654                     .channels = 6,
1655                     .iface = 1,
1656                     .altsetting = 1,
1657                     .altset_idx = 1,
1658                     .endpoint = 0x85,
1659                     .ep_attr = 0x25,
1660                     .rates = SNDRV_PCM_RATE_44100,
1661                     .rate_min = 44100,
1662                     .rate_max = 44100,
1663                     .nr_rates = 1,
1664                     .rate_table = (unsigned int[]) { 44100 }
1665                 }
1666             },
1667             {
1668                 .ifnum = 2,
1669                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1670                 .data = & (const struct snd_usb_midi_endpoint_info) {
1671                     .out_cables = 0x0001,
1672                     .in_cables  = 0x0001
1673                 }
1674             },
1675             {
1676                 .ifnum = 3,
1677                 .type = QUIRK_IGNORE_INTERFACE
1678             },
1679             {
1680                 .ifnum = 4,
1681                 .type = QUIRK_IGNORE_INTERFACE
1682             },
1683             {
1684                 .ifnum = -1
1685             }
1686         }
1687     }
1688 },
1689 {
1690     USB_DEVICE(0x0582, 0x0159),
1691     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1692         /* .vendor_name = "Roland", */
1693         /* .product_name = "UA-22", */
1694         .ifnum = QUIRK_ANY_INTERFACE,
1695         .type = QUIRK_COMPOSITE,
1696         .data = (const struct snd_usb_audio_quirk[]) {
1697             {
1698                 .ifnum = 0,
1699                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1700             },
1701             {
1702                 .ifnum = 1,
1703                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1704             },
1705             {
1706                 .ifnum = 2,
1707                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1708                 .data = & (const struct snd_usb_midi_endpoint_info) {
1709                     .out_cables = 0x0001,
1710                     .in_cables = 0x0001
1711                 }
1712             },
1713             {
1714                 .ifnum = -1
1715             }
1716         }
1717     }
1718 },
1719
1720 /* UA101 and co are supported by another driver */
1721 {
1722     USB_DEVICE(0x0582, 0x0044), /* UA-1000 high speed */
1723     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1724         .ifnum = QUIRK_NODEV_INTERFACE
1725     },
1726 },
1727 {
1728     USB_DEVICE(0x0582, 0x007d), /* UA-101 high speed */
1729     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1730         .ifnum = QUIRK_NODEV_INTERFACE
1731     },
1732 },
1733 {
1734     USB_DEVICE(0x0582, 0x008d), /* UA-101 full speed */
1735     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1736         .ifnum = QUIRK_NODEV_INTERFACE
1737     },
1738 },
1739
1740 /* this catches most recent vendor-specific Roland devices */
1741 {
1742     .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1743                    USB_DEVICE_ID_MATCH_INT_CLASS,
1744     .idVendor = 0x0582,
1745     .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1746     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1747         .ifnum = QUIRK_ANY_INTERFACE,
1748         .type = QUIRK_AUTODETECT
1749     }
1750 },
1751
1752 /* Guillemot devices */
1753 {
1754     /*
1755      * This is for the "Windows Edition" where the external MIDI ports are
1756      * the only MIDI ports; the control data is reported through HID
1757      * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1758      * compliant USB MIDI ports for external MIDI and controls.
1759      */
1760     USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1761     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1762         .vendor_name = "Hercules",
1763         .product_name = "DJ Console (WE)",
1764         .ifnum = 4,
1765         .type = QUIRK_MIDI_FIXED_ENDPOINT,
1766         .data = & (const struct snd_usb_midi_endpoint_info) {
1767             .out_cables = 0x0001,
1768             .in_cables = 0x0001
1769         }
1770     }
1771 },
1772
1773 /* Midiman/M-Audio devices */
1774 {
1775     USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1776     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1777         .vendor_name = "M-Audio",
1778         .product_name = "MidiSport 2x2",
1779         .ifnum = QUIRK_ANY_INTERFACE,
1780         .type = QUIRK_MIDI_MIDIMAN,
1781         .data = & (const struct snd_usb_midi_endpoint_info) {
1782             .out_cables = 0x0003,
1783             .in_cables  = 0x0003
1784         }
1785     }
1786 },
1787 {
1788     USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1789     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1790         .vendor_name = "M-Audio",
1791         .product_name = "MidiSport 1x1",
1792         .ifnum = QUIRK_ANY_INTERFACE,
1793         .type = QUIRK_MIDI_MIDIMAN,
1794         .data = & (const struct snd_usb_midi_endpoint_info) {
1795             .out_cables = 0x0001,
1796             .in_cables  = 0x0001
1797         }
1798     }
1799 },
1800 {
1801     USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1802     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1803         .vendor_name = "M-Audio",
1804         .product_name = "Keystation",
1805         .ifnum = QUIRK_ANY_INTERFACE,
1806         .type = QUIRK_MIDI_MIDIMAN,
1807         .data = & (const struct snd_usb_midi_endpoint_info) {
1808             .out_cables = 0x0001,
1809             .in_cables  = 0x0001
1810         }
1811     }
1812 },
1813 {
1814     USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1815     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1816         .vendor_name = "M-Audio",
1817         .product_name = "MidiSport 4x4",
1818         .ifnum = QUIRK_ANY_INTERFACE,
1819         .type = QUIRK_MIDI_MIDIMAN,
1820         .data = & (const struct snd_usb_midi_endpoint_info) {
1821             .out_cables = 0x000f,
1822             .in_cables  = 0x000f
1823         }
1824     }
1825 },
1826 {
1827     /*
1828      * For hardware revision 1.05; in the later revisions (1.10 and
1829      * 1.21), 0x1031 is the ID for the device without firmware.
1830      * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1831      */
1832     USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1833     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1834         .vendor_name = "M-Audio",
1835         .product_name = "MidiSport 8x8",
1836         .ifnum = QUIRK_ANY_INTERFACE,
1837         .type = QUIRK_MIDI_MIDIMAN,
1838         .data = & (const struct snd_usb_midi_endpoint_info) {
1839             .out_cables = 0x01ff,
1840             .in_cables  = 0x01ff
1841         }
1842     }
1843 },
1844 {
1845     USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1846     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1847         .vendor_name = "M-Audio",
1848         .product_name = "MidiSport 8x8",
1849         .ifnum = QUIRK_ANY_INTERFACE,
1850         .type = QUIRK_MIDI_MIDIMAN,
1851         .data = & (const struct snd_usb_midi_endpoint_info) {
1852             .out_cables = 0x01ff,
1853             .in_cables  = 0x01ff
1854         }
1855     }
1856 },
1857 {
1858     USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1859     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1860         .vendor_name = "M-Audio",
1861         .product_name = "MidiSport 2x4",
1862         .ifnum = QUIRK_ANY_INTERFACE,
1863         .type = QUIRK_MIDI_MIDIMAN,
1864         .data = & (const struct snd_usb_midi_endpoint_info) {
1865             .out_cables = 0x000f,
1866             .in_cables  = 0x0003
1867         }
1868     }
1869 },
1870 {
1871     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1872     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1873         .vendor_name = "M-Audio",
1874         .product_name = "Quattro",
1875         .ifnum = QUIRK_ANY_INTERFACE,
1876         .type = QUIRK_COMPOSITE,
1877         .data = & (const struct snd_usb_audio_quirk[]) {
1878             /*
1879              * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1880              * and share endpoints with the other interfaces.
1881              * Ignore them.  The other interfaces can do 24 bits,
1882              * but captured samples are big-endian (see usbaudio.c).
1883              */
1884             {
1885                 .ifnum = 0,
1886                 .type = QUIRK_IGNORE_INTERFACE
1887             },
1888             {
1889                 .ifnum = 1,
1890                 .type = QUIRK_IGNORE_INTERFACE
1891             },
1892             {
1893                 .ifnum = 2,
1894                 .type = QUIRK_IGNORE_INTERFACE
1895             },
1896             {
1897                 .ifnum = 3,
1898                 .type = QUIRK_IGNORE_INTERFACE
1899             },
1900             {
1901                 .ifnum = 4,
1902                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1903             },
1904             {
1905                 .ifnum = 5,
1906                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1907             },
1908             {
1909                 .ifnum = 6,
1910                 .type = QUIRK_IGNORE_INTERFACE
1911             },
1912             {
1913                 .ifnum = 7,
1914                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1915             },
1916             {
1917                 .ifnum = 8,
1918                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1919             },
1920             {
1921                 .ifnum = 9,
1922                 .type = QUIRK_MIDI_MIDIMAN,
1923                 .data = & (const struct snd_usb_midi_endpoint_info) {
1924                     .out_cables = 0x0001,
1925                     .in_cables  = 0x0001
1926                 }
1927             },
1928             {
1929                 .ifnum = -1
1930             }
1931         }
1932     }
1933 },
1934 {
1935     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1936     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1937         .vendor_name = "M-Audio",
1938         .product_name = "AudioPhile",
1939         .ifnum = 6,
1940         .type = QUIRK_MIDI_MIDIMAN,
1941         .data = & (const struct snd_usb_midi_endpoint_info) {
1942             .out_cables = 0x0001,
1943             .in_cables  = 0x0001
1944         }
1945     }
1946 },
1947 {
1948     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1949     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1950         .vendor_name = "M-Audio",
1951         .product_name = "Ozone",
1952         .ifnum = 3,
1953         .type = QUIRK_MIDI_MIDIMAN,
1954         .data = & (const struct snd_usb_midi_endpoint_info) {
1955             .out_cables = 0x0001,
1956             .in_cables  = 0x0001
1957         }
1958     }
1959 },
1960 {
1961     USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1962     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1963         .vendor_name = "M-Audio",
1964         .product_name = "OmniStudio",
1965         .ifnum = QUIRK_ANY_INTERFACE,
1966         .type = QUIRK_COMPOSITE,
1967         .data = & (const struct snd_usb_audio_quirk[]) {
1968             {
1969                 .ifnum = 0,
1970                 .type = QUIRK_IGNORE_INTERFACE
1971             },
1972             {
1973                 .ifnum = 1,
1974                 .type = QUIRK_IGNORE_INTERFACE
1975             },
1976             {
1977                 .ifnum = 2,
1978                 .type = QUIRK_IGNORE_INTERFACE
1979             },
1980             {
1981                 .ifnum = 3,
1982                 .type = QUIRK_IGNORE_INTERFACE
1983             },
1984             {
1985                 .ifnum = 4,
1986                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1987             },
1988             {
1989                 .ifnum = 5,
1990                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1991             },
1992             {
1993                 .ifnum = 6,
1994                 .type = QUIRK_IGNORE_INTERFACE
1995             },
1996             {
1997                 .ifnum = 7,
1998                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1999             },
2000             {
2001                 .ifnum = 8,
2002                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2003             },
2004             {
2005                 .ifnum = 9,
2006                 .type = QUIRK_MIDI_MIDIMAN,
2007                 .data = & (const struct snd_usb_midi_endpoint_info) {
2008                     .out_cables = 0x0001,
2009                     .in_cables  = 0x0001
2010                 }
2011             },
2012             {
2013                 .ifnum = -1
2014             }
2015         }
2016     }
2017 },
2018 {
2019     USB_DEVICE(0x0763, 0x2019),
2020     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2021         /* .vendor_name = "M-Audio", */
2022         /* .product_name = "Ozone Academic", */
2023         .ifnum = QUIRK_ANY_INTERFACE,
2024         .type = QUIRK_COMPOSITE,
2025         .data = & (const struct snd_usb_audio_quirk[]) {
2026             {
2027                 .ifnum = 0,
2028                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2029             },
2030             {
2031                 .ifnum = 1,
2032                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2033             },
2034             {
2035                 .ifnum = 2,
2036                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2037             },
2038             {
2039                 .ifnum = 3,
2040                 .type = QUIRK_MIDI_MIDIMAN,
2041                 .data = & (const struct snd_usb_midi_endpoint_info) {
2042                     .out_cables = 0x0001,
2043                     .in_cables  = 0x0001
2044                 }
2045             },
2046             {
2047                 .ifnum = -1
2048             }
2049         }
2050     }
2051 },
2052 {
2053     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2054     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2055         /* .vendor_name = "M-Audio", */
2056         /* .product_name = "Fast Track C400", */
2057         .ifnum = QUIRK_ANY_INTERFACE,
2058         .type = QUIRK_COMPOSITE,
2059         .data = &(const struct snd_usb_audio_quirk[]) {
2060             {
2061                 .ifnum = 1,
2062                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2063             },
2064             /* Playback */
2065             {
2066                 .ifnum = 2,
2067                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2068                 .data = &(const struct audioformat) {
2069                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2070                     .channels = 6,
2071                     .iface = 2,
2072                     .altsetting = 1,
2073                     .altset_idx = 1,
2074                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2075                     .endpoint = 0x01,
2076                     .ep_attr = 0x09,
2077                     .rates = SNDRV_PCM_RATE_44100 |
2078                          SNDRV_PCM_RATE_48000 |
2079                          SNDRV_PCM_RATE_88200 |
2080                          SNDRV_PCM_RATE_96000,
2081                     .rate_min = 44100,
2082                     .rate_max = 96000,
2083                     .nr_rates = 4,
2084                     .rate_table = (unsigned int[]) {
2085                             44100, 48000, 88200, 96000
2086                     },
2087                     .clock = 0x80,
2088                 }
2089             },
2090             /* Capture */
2091             {
2092                 .ifnum = 3,
2093                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2094                 .data = &(const struct audioformat) {
2095                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2096                     .channels = 4,
2097                     .iface = 3,
2098                     .altsetting = 1,
2099                     .altset_idx = 1,
2100                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2101                     .endpoint = 0x81,
2102                     .ep_attr = 0x05,
2103                     .rates = SNDRV_PCM_RATE_44100 |
2104                          SNDRV_PCM_RATE_48000 |
2105                          SNDRV_PCM_RATE_88200 |
2106                          SNDRV_PCM_RATE_96000,
2107                     .rate_min = 44100,
2108                     .rate_max = 96000,
2109                     .nr_rates = 4,
2110                     .rate_table = (unsigned int[]) {
2111                         44100, 48000, 88200, 96000
2112                     },
2113                     .clock = 0x80,
2114                 }
2115             },
2116             /* MIDI */
2117             {
2118                 .ifnum = -1 /* Interface = 4 */
2119             }
2120         }
2121     }
2122 },
2123 {
2124     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
2125     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2126         /* .vendor_name = "M-Audio", */
2127         /* .product_name = "Fast Track C600", */
2128         .ifnum = QUIRK_ANY_INTERFACE,
2129         .type = QUIRK_COMPOSITE,
2130         .data = &(const struct snd_usb_audio_quirk[]) {
2131             {
2132                 .ifnum = 1,
2133                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2134             },
2135             /* Playback */
2136             {
2137                 .ifnum = 2,
2138                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2139                 .data = &(const struct audioformat) {
2140                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2141                     .channels = 8,
2142                     .iface = 2,
2143                     .altsetting = 1,
2144                     .altset_idx = 1,
2145                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2146                     .endpoint = 0x01,
2147                     .ep_attr = 0x09,
2148                     .rates = SNDRV_PCM_RATE_44100 |
2149                          SNDRV_PCM_RATE_48000 |
2150                          SNDRV_PCM_RATE_88200 |
2151                          SNDRV_PCM_RATE_96000,
2152                     .rate_min = 44100,
2153                     .rate_max = 96000,
2154                     .nr_rates = 4,
2155                     .rate_table = (unsigned int[]) {
2156                             44100, 48000, 88200, 96000
2157                     },
2158                     .clock = 0x80,
2159                 }
2160             },
2161             /* Capture */
2162             {
2163                 .ifnum = 3,
2164                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2165                 .data = &(const struct audioformat) {
2166                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2167                     .channels = 6,
2168                     .iface = 3,
2169                     .altsetting = 1,
2170                     .altset_idx = 1,
2171                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2172                     .endpoint = 0x81,
2173                     .ep_attr = 0x05,
2174                     .rates = SNDRV_PCM_RATE_44100 |
2175                          SNDRV_PCM_RATE_48000 |
2176                          SNDRV_PCM_RATE_88200 |
2177                          SNDRV_PCM_RATE_96000,
2178                     .rate_min = 44100,
2179                     .rate_max = 96000,
2180                     .nr_rates = 4,
2181                     .rate_table = (unsigned int[]) {
2182                         44100, 48000, 88200, 96000
2183                     },
2184                     .clock = 0x80,
2185                 }
2186             },
2187             /* MIDI */
2188             {
2189                 .ifnum = -1 /* Interface = 4 */
2190             }
2191         }
2192     }
2193 },
2194 {
2195     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2196     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2197         /* .vendor_name = "M-Audio", */
2198         /* .product_name = "Fast Track Ultra", */
2199         .ifnum = QUIRK_ANY_INTERFACE,
2200         .type = QUIRK_COMPOSITE,
2201         .data = & (const struct snd_usb_audio_quirk[]) {
2202             {
2203                 .ifnum = 0,
2204                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2205             },
2206             {
2207                 .ifnum = 1,
2208                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2209                 .data = & (const struct audioformat) {
2210                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2211                     .channels = 8,
2212                     .iface = 1,
2213                     .altsetting = 1,
2214                     .altset_idx = 1,
2215                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2216                     .endpoint = 0x01,
2217                     .ep_attr = 0x09,
2218                     .rates = SNDRV_PCM_RATE_44100 |
2219                          SNDRV_PCM_RATE_48000 |
2220                          SNDRV_PCM_RATE_88200 |
2221                          SNDRV_PCM_RATE_96000,
2222                     .rate_min = 44100,
2223                     .rate_max = 96000,
2224                     .nr_rates = 4,
2225                     .rate_table = (unsigned int[]) {
2226                         44100, 48000, 88200, 96000
2227                     }
2228                 }
2229             },
2230             {
2231                 .ifnum = 2,
2232                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2233                 .data = & (const struct audioformat) {
2234                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2235                     .channels = 8,
2236                     .iface = 2,
2237                     .altsetting = 1,
2238                     .altset_idx = 1,
2239                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2240                     .endpoint = 0x81,
2241                     .ep_attr = 0x05,
2242                     .rates = SNDRV_PCM_RATE_44100 |
2243                          SNDRV_PCM_RATE_48000 |
2244                          SNDRV_PCM_RATE_88200 |
2245                          SNDRV_PCM_RATE_96000,
2246                     .rate_min = 44100,
2247                     .rate_max = 96000,
2248                     .nr_rates = 4,
2249                     .rate_table = (unsigned int[]) {
2250                         44100, 48000, 88200, 96000
2251                     }
2252                 }
2253             },
2254             /* interface 3 (MIDI) is standard compliant */
2255             {
2256                 .ifnum = -1
2257             }
2258         }
2259     }
2260 },
2261 {
2262     USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2263     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2264         /* .vendor_name = "M-Audio", */
2265         /* .product_name = "Fast Track Ultra 8R", */
2266         .ifnum = QUIRK_ANY_INTERFACE,
2267         .type = QUIRK_COMPOSITE,
2268         .data = & (const struct snd_usb_audio_quirk[]) {
2269             {
2270                 .ifnum = 0,
2271                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2272             },
2273             {
2274                 .ifnum = 1,
2275                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2276                 .data = & (const struct audioformat) {
2277                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2278                     .channels = 8,
2279                     .iface = 1,
2280                     .altsetting = 1,
2281                     .altset_idx = 1,
2282                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2283                     .endpoint = 0x01,
2284                     .ep_attr = 0x09,
2285                     .rates = SNDRV_PCM_RATE_44100 |
2286                          SNDRV_PCM_RATE_48000 |
2287                          SNDRV_PCM_RATE_88200 |
2288                          SNDRV_PCM_RATE_96000,
2289                     .rate_min = 44100,
2290                     .rate_max = 96000,
2291                     .nr_rates = 4,
2292                     .rate_table = (unsigned int[]) {
2293                             44100, 48000, 88200, 96000
2294                     }
2295                 }
2296             },
2297             {
2298                 .ifnum = 2,
2299                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2300                 .data = & (const struct audioformat) {
2301                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2302                     .channels = 8,
2303                     .iface = 2,
2304                     .altsetting = 1,
2305                     .altset_idx = 1,
2306                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2307                     .endpoint = 0x81,
2308                     .ep_attr = 0x05,
2309                     .rates = SNDRV_PCM_RATE_44100 |
2310                          SNDRV_PCM_RATE_48000 |
2311                          SNDRV_PCM_RATE_88200 |
2312                          SNDRV_PCM_RATE_96000,
2313                     .rate_min = 44100,
2314                     .rate_max = 96000,
2315                     .nr_rates = 4,
2316                     .rate_table = (unsigned int[]) {
2317                         44100, 48000, 88200, 96000
2318                     }
2319                 }
2320             },
2321             /* interface 3 (MIDI) is standard compliant */
2322             {
2323                 .ifnum = -1
2324             }
2325         }
2326     }
2327 },
2328
2329 /* Casio devices */
2330 {
2331     USB_DEVICE(0x07cf, 0x6801),
2332     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2333         .vendor_name = "Casio",
2334         .product_name = "PL-40R",
2335         .ifnum = 0,
2336         .type = QUIRK_MIDI_YAMAHA
2337     }
2338 },
2339 {
2340     /* this ID is used by several devices without a product ID */
2341     USB_DEVICE(0x07cf, 0x6802),
2342     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2343         .vendor_name = "Casio",
2344         .product_name = "Keyboard",
2345         .ifnum = 0,
2346         .type = QUIRK_MIDI_YAMAHA
2347     }
2348 },
2349
2350 /* Mark of the Unicorn devices */
2351 {
2352     /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2353     .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2354                USB_DEVICE_ID_MATCH_PRODUCT |
2355                USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2356     .idVendor = 0x07fd,
2357     .idProduct = 0x0001,
2358     .bDeviceSubClass = 2,
2359     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2360         .vendor_name = "MOTU",
2361         .product_name = "Fastlane",
2362         .ifnum = QUIRK_ANY_INTERFACE,
2363         .type = QUIRK_COMPOSITE,
2364         .data = & (const struct snd_usb_audio_quirk[]) {
2365             {
2366                 .ifnum = 0,
2367                 .type = QUIRK_MIDI_RAW_BYTES
2368             },
2369             {
2370                 .ifnum = 1,
2371                 .type = QUIRK_IGNORE_INTERFACE
2372             },
2373             {
2374                 .ifnum = -1
2375             }
2376         }
2377     }
2378 },
2379
2380 /* Emagic devices */
2381 {
2382     USB_DEVICE(0x086a, 0x0001),
2383     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2384         .vendor_name = "Emagic",
2385         .product_name = "Unitor8",
2386         .ifnum = 2,
2387         .type = QUIRK_MIDI_EMAGIC,
2388         .data = & (const struct snd_usb_midi_endpoint_info) {
2389             .out_cables = 0x80ff,
2390             .in_cables  = 0x80ff
2391         }
2392     }
2393 },
2394 {
2395     USB_DEVICE(0x086a, 0x0002),
2396     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2397         .vendor_name = "Emagic",
2398         /* .product_name = "AMT8", */
2399         .ifnum = 2,
2400         .type = QUIRK_MIDI_EMAGIC,
2401         .data = & (const struct snd_usb_midi_endpoint_info) {
2402             .out_cables = 0x80ff,
2403             .in_cables  = 0x80ff
2404         }
2405     }
2406 },
2407 {
2408     USB_DEVICE(0x086a, 0x0003),
2409     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2410         .vendor_name = "Emagic",
2411         /* .product_name = "MT4", */
2412         .ifnum = 2,
2413         .type = QUIRK_MIDI_EMAGIC,
2414         .data = & (const struct snd_usb_midi_endpoint_info) {
2415             .out_cables = 0x800f,
2416             .in_cables  = 0x8003
2417         }
2418     }
2419 },
2420
2421 /* KORG devices */
2422 {
2423     USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2424     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2425         .vendor_name = "KORG, Inc.",
2426         /* .product_name = "PANDORA PX5D", */
2427         .ifnum = 3,
2428         .type = QUIRK_MIDI_STANDARD_INTERFACE,
2429     }
2430 },
2431
2432 {
2433     USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2434     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2435         .vendor_name = "KORG, Inc.",
2436         /* .product_name = "ToneLab ST", */
2437         .ifnum = 3,
2438         .type = QUIRK_MIDI_STANDARD_INTERFACE,
2439     }
2440 },
2441
2442 {
2443     USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204),
2444     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2445         .vendor_name = "KORG, Inc.",
2446         /* .product_name = "ToneLab EX", */
2447         .ifnum = 3,
2448         .type = QUIRK_MIDI_STANDARD_INTERFACE,
2449     }
2450 },
2451
2452 /* AKAI devices */
2453 {
2454     USB_DEVICE(0x09e8, 0x0062),
2455     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2456         .vendor_name = "AKAI",
2457         .product_name = "MPD16",
2458         .ifnum = 0,
2459         .type = QUIRK_MIDI_AKAI,
2460     }
2461 },
2462
2463 {
2464     /* Akai MPC Element */
2465     USB_DEVICE(0x09e8, 0x0021),
2466     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2467         .ifnum = QUIRK_ANY_INTERFACE,
2468         .type = QUIRK_COMPOSITE,
2469         .data = & (const struct snd_usb_audio_quirk[]) {
2470             {
2471                 .ifnum = 0,
2472                 .type = QUIRK_IGNORE_INTERFACE
2473             },
2474             {
2475                 .ifnum = 1,
2476                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2477             },
2478             {
2479                 .ifnum = -1
2480             }
2481         }
2482     }
2483 },
2484
2485 /* Steinberg devices */
2486 {
2487     /* Steinberg MI2 */
2488     USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2489     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2490         .ifnum = QUIRK_ANY_INTERFACE,
2491         .type = QUIRK_COMPOSITE,
2492         .data = & (const struct snd_usb_audio_quirk[]) {
2493             {
2494                 .ifnum = 0,
2495                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2496             },
2497             {
2498                 .ifnum = 1,
2499                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2500             },
2501             {
2502                 .ifnum = 2,
2503                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2504             },
2505             {
2506                 .ifnum = 3,
2507                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2508                 .data = &(const struct snd_usb_midi_endpoint_info) {
2509                     .out_cables = 0x0001,
2510                     .in_cables  = 0x0001
2511                 }
2512             },
2513             {
2514                 .ifnum = -1
2515             }
2516         }
2517     }
2518 },
2519 {
2520     /* Steinberg MI4 */
2521     USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2522     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2523         .ifnum = QUIRK_ANY_INTERFACE,
2524         .type = QUIRK_COMPOSITE,
2525         .data = & (const struct snd_usb_audio_quirk[]) {
2526             {
2527                 .ifnum = 0,
2528                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2529             },
2530             {
2531                 .ifnum = 1,
2532                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2533             },
2534             {
2535                 .ifnum = 2,
2536                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2537             },
2538             {
2539                 .ifnum = 3,
2540                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2541                 .data = &(const struct snd_usb_midi_endpoint_info) {
2542                     .out_cables = 0x0001,
2543                     .in_cables  = 0x0001
2544                 }
2545             },
2546             {
2547                 .ifnum = -1
2548             }
2549         }
2550     }
2551 },
2552
2553 /* TerraTec devices */
2554 {
2555     USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2556     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2557         .vendor_name = "TerraTec",
2558         .product_name = "PHASE 26",
2559         .ifnum = 3,
2560         .type = QUIRK_MIDI_STANDARD_INTERFACE
2561     }
2562 },
2563 {
2564     USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2565     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2566         .vendor_name = "TerraTec",
2567         .product_name = "PHASE 26",
2568         .ifnum = 3,
2569         .type = QUIRK_MIDI_STANDARD_INTERFACE
2570     }
2571 },
2572 {
2573     USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2574     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2575         .vendor_name = "TerraTec",
2576         .product_name = "PHASE 26",
2577         .ifnum = 3,
2578         .type = QUIRK_MIDI_STANDARD_INTERFACE
2579     }
2580 },
2581 {
2582     USB_DEVICE(0x0ccd, 0x0035),
2583     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2584         .vendor_name = "Miditech",
2585         .product_name = "Play'n Roll",
2586         .ifnum = 0,
2587         .type = QUIRK_MIDI_CME
2588     }
2589 },
2590
2591 /* Novation EMS devices */
2592 {
2593     USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2594     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2595         .vendor_name = "Novation",
2596         .product_name = "ReMOTE Audio/XStation",
2597         .ifnum = 4,
2598         .type = QUIRK_MIDI_NOVATION
2599     }
2600 },
2601 {
2602     USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2603     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2604         .vendor_name = "Novation",
2605         .product_name = "Speedio",
2606         .ifnum = 3,
2607         .type = QUIRK_MIDI_NOVATION
2608     }
2609 },
2610 {
2611     USB_DEVICE(0x1235, 0x000a),
2612     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2613         /* .vendor_name = "Novation", */
2614         /* .product_name = "Nocturn", */
2615         .ifnum = 0,
2616         .type = QUIRK_MIDI_RAW_BYTES
2617     }
2618 },
2619 {
2620     USB_DEVICE(0x1235, 0x000e),
2621     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2622         /* .vendor_name = "Novation", */
2623         /* .product_name = "Launchpad", */
2624         .ifnum = 0,
2625         .type = QUIRK_MIDI_RAW_BYTES
2626     }
2627 },
2628 {
2629     USB_DEVICE(0x1235, 0x0010),
2630     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2631         .vendor_name = "Focusrite",
2632         .product_name = "Saffire 6 USB",
2633         .ifnum = QUIRK_ANY_INTERFACE,
2634         .type = QUIRK_COMPOSITE,
2635         .data = (const struct snd_usb_audio_quirk[]) {
2636             {
2637                 .ifnum = 0,
2638                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2639             },
2640             {
2641                 .ifnum = 0,
2642                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2643                 .data = &(const struct audioformat) {
2644                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2645                     .channels = 4,
2646                     .iface = 0,
2647                     .altsetting = 1,
2648                     .altset_idx = 1,
2649                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2650                     .endpoint = 0x01,
2651                     .ep_attr = USB_ENDPOINT_XFER_ISOC,
2652                     .datainterval = 1,
2653                     .maxpacksize = 0x024c,
2654                     .rates = SNDRV_PCM_RATE_44100 |
2655                          SNDRV_PCM_RATE_48000,
2656                     .rate_min = 44100,
2657                     .rate_max = 48000,
2658                     .nr_rates = 2,
2659                     .rate_table = (unsigned int[]) {
2660                         44100, 48000
2661                     },
2662                     .sync_ep = 0x82,
2663                     .sync_iface = 0,
2664                     .sync_altsetting = 1,
2665                     .sync_ep_idx = 1,
2666                     .implicit_fb = 1,
2667                 }
2668             },
2669             {
2670                 .ifnum = 0,
2671                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2672                 .data = &(const struct audioformat) {
2673                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2674                     .channels = 2,
2675                     .iface = 0,
2676                     .altsetting = 1,
2677                     .altset_idx = 1,
2678                     .attributes = 0,
2679                     .endpoint = 0x82,
2680                     .ep_idx = 1,
2681                     .ep_attr = USB_ENDPOINT_XFER_ISOC,
2682                     .datainterval = 1,
2683                     .maxpacksize = 0x0126,
2684                     .rates = SNDRV_PCM_RATE_44100 |
2685                          SNDRV_PCM_RATE_48000,
2686                     .rate_min = 44100,
2687                     .rate_max = 48000,
2688                     .nr_rates = 2,
2689                     .rate_table = (unsigned int[]) {
2690                         44100, 48000
2691                     }
2692                 }
2693             },
2694             {
2695                 .ifnum = 1,
2696                 .type = QUIRK_MIDI_RAW_BYTES
2697             },
2698             {
2699                 .ifnum = -1
2700             }
2701         }
2702     }
2703 },
2704 {
2705     USB_DEVICE(0x1235, 0x0018),
2706     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2707         .vendor_name = "Novation",
2708         .product_name = "Twitch",
2709         .ifnum = QUIRK_ANY_INTERFACE,
2710         .type = QUIRK_COMPOSITE,
2711         .data = (const struct snd_usb_audio_quirk[]) {
2712             {
2713                 .ifnum = 0,
2714                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2715                 .data = & (const struct audioformat) {
2716                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2717                     .channels = 4,
2718                     .iface = 0,
2719                     .altsetting = 1,
2720                     .altset_idx = 1,
2721                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2722                     .endpoint = 0x01,
2723                     .ep_attr = USB_ENDPOINT_XFER_ISOC,
2724                     .rates = SNDRV_PCM_RATE_44100 |
2725                          SNDRV_PCM_RATE_48000,
2726                     .rate_min = 44100,
2727                     .rate_max = 48000,
2728                     .nr_rates = 2,
2729                     .rate_table = (unsigned int[]) {
2730                         44100, 48000
2731                     }
2732                 }
2733             },
2734             {
2735                 .ifnum = 1,
2736                 .type = QUIRK_MIDI_RAW_BYTES
2737             },
2738             {
2739                 .ifnum = -1
2740             }
2741         }
2742     }
2743 },
2744 {
2745     USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2746     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2747         .vendor_name = "Novation",
2748         .product_name = "ReMOTE25",
2749         .ifnum = 0,
2750         .type = QUIRK_MIDI_NOVATION
2751     }
2752 },
2753
2754 /* Access Music devices */
2755 {
2756     /* VirusTI Desktop */
2757     USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2758     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2759         .ifnum = QUIRK_ANY_INTERFACE,
2760         .type = QUIRK_COMPOSITE,
2761         .data = &(const struct snd_usb_audio_quirk[]) {
2762             {
2763                 .ifnum = 3,
2764                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2765                 .data = &(const struct snd_usb_midi_endpoint_info) {
2766                     .out_cables = 0x0003,
2767                     .in_cables  = 0x0003
2768                 }
2769             },
2770             {
2771                 .ifnum = 4,
2772                 .type = QUIRK_IGNORE_INTERFACE
2773             },
2774             {
2775                 .ifnum = -1
2776             }
2777         }
2778     }
2779 },
2780
2781 /* Native Instruments MK2 series */
2782 {
2783     /* Komplete Audio 6 */
2784     .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2785     .idVendor = 0x17cc,
2786     .idProduct = 0x1000,
2787 },
2788 {
2789     /* Traktor Audio 6 */
2790     .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2791     .idVendor = 0x17cc,
2792     .idProduct = 0x1010,
2793 },
2794 {
2795     /* Traktor Audio 10 */
2796     .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2797     .idVendor = 0x17cc,
2798     .idProduct = 0x1020,
2799 },
2800
2801 /* QinHeng devices */
2802 {
2803     USB_DEVICE(0x1a86, 0x752d),
2804     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2805         .vendor_name = "QinHeng",
2806         .product_name = "CH345",
2807         .ifnum = 1,
2808         .type = QUIRK_MIDI_CH345
2809     }
2810 },
2811
2812 /* KeithMcMillen Stringport */
2813 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */
2814
2815 /* Miditech devices */
2816 {
2817     USB_DEVICE(0x4752, 0x0011),
2818     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2819         .vendor_name = "Miditech",
2820         .product_name = "Midistart-2",
2821         .ifnum = 0,
2822         .type = QUIRK_MIDI_CME
2823     }
2824 },
2825
2826 /* Central Music devices */
2827 {
2828     /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2829     USB_DEVICE(0x7104, 0x2202),
2830     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2831         .ifnum = 0,
2832         .type = QUIRK_MIDI_CME
2833     }
2834 },
2835
2836 /* Digidesign Mbox */
2837 {
2838     /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2839     USB_DEVICE(0x0dba, 0x1000),
2840     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2841         .vendor_name = "Digidesign",
2842         .product_name = "MBox",
2843         .ifnum = QUIRK_ANY_INTERFACE,
2844         .type = QUIRK_COMPOSITE,
2845         .data = (const struct snd_usb_audio_quirk[]){
2846             {
2847                 .ifnum = 0,
2848                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2849             },
2850             {
2851                 .ifnum = 1,
2852                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2853                 .data = &(const struct audioformat) {
2854                     .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2855                     .channels = 2,
2856                     .iface = 1,
2857                     .altsetting = 1,
2858                     .altset_idx = 1,
2859                     .attributes = 0x4,
2860                     .endpoint = 0x02,
2861                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
2862                         USB_ENDPOINT_SYNC_SYNC,
2863                     .maxpacksize = 0x130,
2864                     .rates = SNDRV_PCM_RATE_48000,
2865                     .rate_min = 48000,
2866                     .rate_max = 48000,
2867                     .nr_rates = 1,
2868                     .rate_table = (unsigned int[]) {
2869                         48000
2870                     }
2871                 }
2872             },
2873             {
2874                 .ifnum = 1,
2875                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2876                 .data = &(const struct audioformat) {
2877                     .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2878                     .channels = 2,
2879                     .iface = 1,
2880                     .altsetting = 1,
2881                     .altset_idx = 1,
2882                     .attributes = 0x4,
2883                     .endpoint = 0x81,
2884                     .ep_idx = 1,
2885                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
2886                         USB_ENDPOINT_SYNC_ASYNC,
2887                     .maxpacksize = 0x130,
2888                     .rates = SNDRV_PCM_RATE_48000,
2889                     .rate_min = 48000,
2890                     .rate_max = 48000,
2891                     .nr_rates = 1,
2892                     .rate_table = (unsigned int[]) {
2893                         48000
2894                     }
2895                 }
2896             },
2897             {
2898                 .ifnum = -1
2899             }
2900         }
2901     }
2902 },
2903
2904 /* DIGIDESIGN MBOX 2 */
2905 {
2906     USB_DEVICE(0x0dba, 0x3000),
2907     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2908         .vendor_name = "Digidesign",
2909         .product_name = "Mbox 2",
2910         .ifnum = QUIRK_ANY_INTERFACE,
2911         .type = QUIRK_COMPOSITE,
2912         .data = (const struct snd_usb_audio_quirk[]) {
2913             {
2914                 .ifnum = 0,
2915                 .type = QUIRK_IGNORE_INTERFACE
2916             },
2917             {
2918                 .ifnum = 1,
2919                 .type = QUIRK_IGNORE_INTERFACE
2920             },
2921             {
2922                 .ifnum = 2,
2923                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2924                 .data = &(const struct audioformat) {
2925                     .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2926                     .channels = 2,
2927                     .iface = 2,
2928                     .altsetting = 2,
2929                     .altset_idx = 1,
2930                     .attributes = 0x00,
2931                     .endpoint = 0x03,
2932                     .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
2933                     .rates = SNDRV_PCM_RATE_48000,
2934                     .rate_min = 48000,
2935                     .rate_max = 48000,
2936                     .nr_rates = 1,
2937                     .rate_table = (unsigned int[]) {
2938                         48000
2939                     }
2940                 }
2941             },
2942             {
2943                 .ifnum = 3,
2944                 .type = QUIRK_IGNORE_INTERFACE
2945             },
2946             {
2947                 .ifnum = 4,
2948                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2949                 .data = &(const struct audioformat) {
2950                 .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2951                     .channels = 2,
2952                     .iface = 4,
2953                     .altsetting = 2,
2954                     .altset_idx = 1,
2955                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2956                     .endpoint = 0x85,
2957                     .ep_attr = USB_ENDPOINT_SYNC_SYNC,
2958                     .rates = SNDRV_PCM_RATE_48000,
2959                     .rate_min = 48000,
2960                     .rate_max = 48000,
2961                     .nr_rates = 1,
2962                     .rate_table = (unsigned int[]) {
2963                         48000
2964                     }
2965                 }
2966             },
2967             {
2968                 .ifnum = 5,
2969                 .type = QUIRK_IGNORE_INTERFACE
2970             },
2971             {
2972                 .ifnum = 6,
2973                 .type = QUIRK_MIDI_MIDIMAN,
2974                 .data = &(const struct snd_usb_midi_endpoint_info) {
2975                     .out_ep =  0x02,
2976                     .out_cables = 0x0001,
2977                     .in_ep = 0x81,
2978                     .in_interval = 0x01,
2979                     .in_cables = 0x0001
2980                 }
2981             },
2982             {
2983                 .ifnum = -1
2984             }
2985         }
2986     }
2987 },
2988 {
2989     /* Tascam US122 MKII - playback-only support */
2990     USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021),
2991     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2992         .vendor_name = "TASCAM",
2993         .product_name = "US122 MKII",
2994         .ifnum = QUIRK_ANY_INTERFACE,
2995         .type = QUIRK_COMPOSITE,
2996         .data = (const struct snd_usb_audio_quirk[]) {
2997             {
2998                 .ifnum = 0,
2999                 .type = QUIRK_IGNORE_INTERFACE
3000             },
3001             {
3002                 .ifnum = 1,
3003                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3004                 .data = &(const struct audioformat) {
3005                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3006                     .channels = 2,
3007                     .iface = 1,
3008                     .altsetting = 1,
3009                     .altset_idx = 1,
3010                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3011                     .endpoint = 0x02,
3012                     .ep_attr = USB_ENDPOINT_XFER_ISOC,
3013                     .rates = SNDRV_PCM_RATE_44100 |
3014                          SNDRV_PCM_RATE_48000 |
3015                          SNDRV_PCM_RATE_88200 |
3016                          SNDRV_PCM_RATE_96000,
3017                     .rate_min = 44100,
3018                     .rate_max = 96000,
3019                     .nr_rates = 4,
3020                     .rate_table = (unsigned int[]) {
3021                         44100, 48000, 88200, 96000
3022                     }
3023                 }
3024             },
3025             {
3026                 .ifnum = -1
3027             }
3028         }
3029     }
3030 },
3031
3032 /* Denon DN-X1600 */
3033 {
3034     USB_AUDIO_DEVICE(0x154e, 0x500e),
3035     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3036         .vendor_name = "Denon",
3037         .product_name = "DN-X1600",
3038         .ifnum = QUIRK_ANY_INTERFACE,
3039         .type = QUIRK_COMPOSITE,
3040         .data = (const struct snd_usb_audio_quirk[]){
3041             {
3042                 .ifnum = 0,
3043                 .type = QUIRK_IGNORE_INTERFACE,
3044             },
3045             {
3046                 .ifnum = 1,
3047                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3048                 .data = &(const struct audioformat) {
3049                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3050                     .channels = 8,
3051                     .iface = 1,
3052                     .altsetting = 1,
3053                     .altset_idx = 1,
3054                     .attributes = 0x0,
3055                     .endpoint = 0x01,
3056                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
3057                         USB_ENDPOINT_SYNC_ADAPTIVE,
3058                     .maxpacksize = 0x138,
3059                     .rates = SNDRV_PCM_RATE_48000,
3060                     .rate_min = 48000,
3061                     .rate_max = 48000,
3062                     .nr_rates = 1,
3063                     .rate_table = (unsigned int[]) {
3064                         48000
3065                     }
3066                 }
3067             },
3068             {
3069                 .ifnum = 2,
3070                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3071                 .data = &(const struct audioformat) {
3072                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3073                     .channels = 8,
3074                     .iface = 2,
3075                     .altsetting = 1,
3076                     .altset_idx = 1,
3077                     .attributes = 0x0,
3078                     .endpoint = 0x85,
3079                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
3080                         USB_ENDPOINT_SYNC_ADAPTIVE,
3081                     .maxpacksize = 0x138,
3082                     .rates = SNDRV_PCM_RATE_48000,
3083                     .rate_min = 48000,
3084                     .rate_max = 48000,
3085                     .nr_rates = 1,
3086                     .rate_table = (unsigned int[]) {
3087                         48000
3088                     }
3089                 }
3090             },
3091             {
3092                 .ifnum = 4,
3093                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
3094             },
3095             {
3096                 .ifnum = -1
3097             }
3098         }
3099     }
3100 },
3101
3102 /* Microsoft XboxLive Headset/Xbox Communicator */
3103 {
3104     USB_DEVICE(0x045e, 0x0283),
3105     .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3106     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3107         .vendor_name = "Microsoft",
3108         .product_name = "XboxLive Headset/Xbox Communicator",
3109         .ifnum = QUIRK_ANY_INTERFACE,
3110         .type = QUIRK_COMPOSITE,
3111         .data = &(const struct snd_usb_audio_quirk[]) {
3112             {
3113                 /* playback */
3114                 .ifnum = 0,
3115                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3116                 .data = &(const struct audioformat) {
3117                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
3118                     .channels = 1,
3119                     .iface = 0,
3120                     .altsetting = 0,
3121                     .altset_idx = 0,
3122                     .attributes = 0,
3123                     .endpoint = 0x04,
3124                     .ep_attr = 0x05,
3125                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
3126                     .rate_min = 22050,
3127                     .rate_max = 22050
3128                 }
3129             },
3130             {
3131                 /* capture */
3132                 .ifnum = 1,
3133                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3134                 .data = &(const struct audioformat) {
3135                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
3136                     .channels = 1,
3137                     .iface = 1,
3138                     .altsetting = 0,
3139                     .altset_idx = 0,
3140                     .attributes = 0,
3141                     .endpoint = 0x85,
3142                     .ep_attr = 0x05,
3143                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
3144                     .rate_min = 16000,
3145                     .rate_max = 16000
3146                 }
3147             },
3148             {
3149                 .ifnum = -1
3150             }
3151         }
3152     }
3153 },
3154
3155 /* Reloop Play */
3156 {
3157     USB_DEVICE(0x200c, 0x100b),
3158     .bInterfaceClass = USB_CLASS_PER_INTERFACE,
3159     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3160         .ifnum = QUIRK_ANY_INTERFACE,
3161         .type = QUIRK_COMPOSITE,
3162         .data = &(const struct snd_usb_audio_quirk[]) {
3163             {
3164                 .ifnum = 0,
3165                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3166             },
3167             {
3168                 .ifnum = 1,
3169                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3170                 .data = &(const struct audioformat) {
3171                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3172                     .channels = 4,
3173                     .iface = 1,
3174                     .altsetting = 1,
3175                     .altset_idx = 1,
3176                     .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3177                     .endpoint = 0x01,
3178                     .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3179                     .rates = SNDRV_PCM_RATE_44100 |
3180                          SNDRV_PCM_RATE_48000,
3181                     .rate_min = 44100,
3182                     .rate_max = 48000,
3183                     .nr_rates = 2,
3184                     .rate_table = (unsigned int[]) {
3185                         44100, 48000
3186                     }
3187                 }
3188             },
3189             {
3190                 .ifnum = -1
3191             }
3192         }
3193     }
3194 },
3195
3196 {
3197     /*
3198      * ZOOM R16/24 in audio interface mode.
3199      * Playback requires an extra four byte LE length indicator
3200      * at the start of each isochronous packet. This quirk is
3201      * enabled in create_standard_audio_quirk().
3202      */
3203     USB_DEVICE(0x1686, 0x00dd),
3204     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3205         .ifnum = QUIRK_ANY_INTERFACE,
3206         .type = QUIRK_COMPOSITE,
3207         .data = (const struct snd_usb_audio_quirk[]) {
3208             {
3209                 /* Playback  */
3210                 .ifnum = 1,
3211                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3212             },
3213             {
3214                 /* Capture */
3215                 .ifnum = 2,
3216                 .type = QUIRK_AUDIO_STANDARD_INTERFACE,
3217             },
3218             {
3219                 /* Midi */
3220                 .ifnum = 3,
3221                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3222             },
3223             {
3224                 .ifnum = -1
3225             },
3226         }
3227     }
3228 },
3229
3230 {
3231     /*
3232      * Some USB MIDI devices don't have an audio control interface,
3233      * so we have to grab MIDI streaming interfaces here.
3234      */
3235     .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3236                USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3237     .bInterfaceClass = USB_CLASS_AUDIO,
3238     .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3239     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3240         .ifnum = QUIRK_ANY_INTERFACE,
3241         .type = QUIRK_MIDI_STANDARD_INTERFACE
3242     }
3243 },
3244
3245 /* Rane SL-1 */
3246 {
3247     USB_DEVICE(0x13e5, 0x0001),
3248     .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3249         .ifnum = QUIRK_ANY_INTERFACE,
3250         .type = QUIRK_AUDIO_STANDARD_INTERFACE
3251         }
3252 },
3253
3254 /* disabled due to regression for other devices;
3255  * see https://bugzilla.kernel.org/show_bug.cgi?id=199905
3256  */
3257 #if 0
3258 {
3259     /*
3260      * Nura's first gen headphones use Cambridge Silicon Radio's vendor
3261      * ID, but it looks like the product ID actually is only for Nura.
3262      * The capture interface does not work at all (even on Windows),
3263      * and only the 48 kHz sample rate works for the playback interface.
3264      */
3265     USB_DEVICE(0x0a12, 0x1243),
3266     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3267         .ifnum = QUIRK_ANY_INTERFACE,
3268         .type = QUIRK_COMPOSITE,
3269         .data = (const struct snd_usb_audio_quirk[]) {
3270             {
3271                 .ifnum = 0,
3272                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3273             },
3274             /* Capture */
3275             {
3276                 .ifnum = 1,
3277                 .type = QUIRK_IGNORE_INTERFACE,
3278             },
3279             /* Playback */
3280             {
3281                 .ifnum = 2,
3282                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3283                 .data = &(const struct audioformat) {
3284                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
3285                     .channels = 2,
3286                     .iface = 2,
3287                     .altsetting = 1,
3288                     .altset_idx = 1,
3289                     .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3290                         UAC_EP_CS_ATTR_SAMPLE_RATE,
3291                     .endpoint = 0x03,
3292                     .ep_attr = USB_ENDPOINT_XFER_ISOC,
3293                     .rates = SNDRV_PCM_RATE_48000,
3294                     .rate_min = 48000,
3295                     .rate_max = 48000,
3296                     .nr_rates = 1,
3297                     .rate_table = (unsigned int[]) {
3298                         48000
3299                     }
3300                 }
3301             },
3302             {
3303                 .ifnum = -1
3304             },
3305         }
3306     }
3307 },
3308 #endif /* disabled */
3309
3310 {
3311     /*
3312      * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
3313      * even though it advertises more. The capture interface doesn't work
3314      * even on windows.
3315      */
3316     USB_DEVICE(0x19b5, 0x0021),
3317     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3318         .ifnum = QUIRK_ANY_INTERFACE,
3319         .type = QUIRK_COMPOSITE,
3320         .data = (const struct snd_usb_audio_quirk[]) {
3321             {
3322                 .ifnum = 0,
3323                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3324             },
3325             /* Playback */
3326             {
3327                 .ifnum = 1,
3328                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3329                 .data = &(const struct audioformat) {
3330                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
3331                     .channels = 2,
3332                     .iface = 1,
3333                     .altsetting = 1,
3334                     .altset_idx = 1,
3335                     .attributes = UAC_EP_CS_ATTR_FILL_MAX |
3336                         UAC_EP_CS_ATTR_SAMPLE_RATE,
3337                     .endpoint = 0x03,
3338                     .ep_attr = USB_ENDPOINT_XFER_ISOC,
3339                     .rates = SNDRV_PCM_RATE_48000,
3340                     .rate_min = 48000,
3341                     .rate_max = 48000,
3342                     .nr_rates = 1,
3343                     .rate_table = (unsigned int[]) {
3344                         48000
3345                     }
3346                 }
3347             },
3348             {
3349                 .ifnum = -1
3350             },
3351         }
3352     }
3353 },
3354 /* MOTU Microbook II */
3355 {
3356     USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004),
3357     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3358         .vendor_name = "MOTU",
3359         .product_name = "MicroBookII",
3360         .ifnum = QUIRK_ANY_INTERFACE,
3361         .type = QUIRK_COMPOSITE,
3362         .data = (const struct snd_usb_audio_quirk[]) {
3363             {
3364                 .ifnum = 0,
3365                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3366             },
3367             {
3368                 .ifnum = 0,
3369                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3370                 .data = &(const struct audioformat) {
3371                     .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3372                     .channels = 6,
3373                     .iface = 0,
3374                     .altsetting = 1,
3375                     .altset_idx = 1,
3376                     .attributes = 0,
3377                     .endpoint = 0x84,
3378                     .rates = SNDRV_PCM_RATE_96000,
3379                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
3380                            USB_ENDPOINT_SYNC_ASYNC,
3381                     .rate_min = 96000,
3382                     .rate_max = 96000,
3383                     .nr_rates = 1,
3384                     .maxpacksize = 0x00d8,
3385                     .rate_table = (unsigned int[]) {
3386                         96000
3387                     }
3388                 }
3389             },
3390             {
3391                 .ifnum = 0,
3392                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3393                 .data = &(const struct audioformat) {
3394                     .formats = SNDRV_PCM_FMTBIT_S24_3BE,
3395                     .channels = 8,
3396                     .iface = 0,
3397                     .altsetting = 1,
3398                     .altset_idx = 1,
3399                     .attributes = 0,
3400                     .endpoint = 0x03,
3401                     .ep_idx = 1,
3402                     .rates = SNDRV_PCM_RATE_96000,
3403                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
3404                            USB_ENDPOINT_SYNC_ASYNC,
3405                     .rate_min = 96000,
3406                     .rate_max = 96000,
3407                     .nr_rates = 1,
3408                     .maxpacksize = 0x0120,
3409                     .rate_table = (unsigned int[]) {
3410                         96000
3411                     }
3412                 }
3413             },
3414             {
3415                 .ifnum = -1
3416             }
3417         }
3418     }
3419 },
3420 {
3421     /*
3422      * PIONEER DJ DDJ-SX3
3423      * PCM is 12 channels out, 10 channels in @ 44.1 fixed
3424      * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86
3425      * The feedback for the output is the input.
3426      */
3427     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023),
3428     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3429         .ifnum = QUIRK_ANY_INTERFACE,
3430         .type = QUIRK_COMPOSITE,
3431         .data = (const struct snd_usb_audio_quirk[]) {
3432             {
3433                 .ifnum = 0,
3434                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3435                 .data = &(const struct audioformat) {
3436                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
3437                     .channels = 12,
3438                     .iface = 0,
3439                     .altsetting = 1,
3440                     .altset_idx = 1,
3441                     .endpoint = 0x05,
3442                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3443                            USB_ENDPOINT_SYNC_ASYNC,
3444                     .rates = SNDRV_PCM_RATE_44100,
3445                     .rate_min = 44100,
3446                     .rate_max = 44100,
3447                     .nr_rates = 1,
3448                     .rate_table = (unsigned int[]) { 44100 }
3449                 }
3450             },
3451             {
3452                 .ifnum = 0,
3453                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3454                 .data = &(const struct audioformat) {
3455                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
3456                     .channels = 10,
3457                     .iface = 0,
3458                     .altsetting = 1,
3459                     .altset_idx = 1,
3460                     .endpoint = 0x86,
3461                     .ep_idx = 1,
3462                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3463                          USB_ENDPOINT_SYNC_ASYNC|
3464                          USB_ENDPOINT_USAGE_IMPLICIT_FB,
3465                     .rates = SNDRV_PCM_RATE_44100,
3466                     .rate_min = 44100,
3467                     .rate_max = 44100,
3468                     .nr_rates = 1,
3469                     .rate_table = (unsigned int[]) { 44100 }
3470                 }
3471             },
3472             {
3473                 .ifnum = -1
3474             }
3475         }
3476     }
3477 },
3478 {
3479     /*
3480      * Pioneer DJ DJM-250MK2
3481      * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
3482      * and 8 channels in @ 48 fixed (endpoint 0x82).
3483      *
3484      * Both playback and recording is working, even simultaneously.
3485      *
3486      * Playback channels could be mapped to:
3487      *  - CH1
3488      *  - CH2
3489      *  - AUX
3490      *
3491      * Recording channels could be mapped to:
3492      *  - Post CH1 Fader
3493      *  - Post CH2 Fader
3494      *  - Cross Fader A
3495      *  - Cross Fader B
3496      *  - MIC
3497      *  - AUX
3498      *  - REC OUT
3499      *
3500      * There is remaining problem with recording directly from PHONO/LINE.
3501      * If we map a channel to:
3502      *  - CH1 Control Tone PHONO
3503      *  - CH1 Control Tone LINE
3504      *  - CH2 Control Tone PHONO
3505      *  - CH2 Control Tone LINE
3506      * it is silent.
3507      * There is no signal even on other operating systems with official drivers.
3508      * The signal appears only when a supported application is started.
3509      * This needs to be investigated yet...
3510      * (there is quite a lot communication on the USB in both directions)
3511      *
3512      * In current version this mixer could be used for playback
3513      * and for recording from vinyls (through Post CH* Fader)
3514      * but not for DVS (Digital Vinyl Systems) like in Mixxx.
3515      */
3516     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017),
3517     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3518         .ifnum = QUIRK_ANY_INTERFACE,
3519         .type = QUIRK_COMPOSITE,
3520         .data = (const struct snd_usb_audio_quirk[]) {
3521             {
3522                 .ifnum = 0,
3523                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3524                 .data = &(const struct audioformat) {
3525                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3526                     .channels = 8, // outputs
3527                     .iface = 0,
3528                     .altsetting = 1,
3529                     .altset_idx = 1,
3530                     .endpoint = 0x01,
3531                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3532                         USB_ENDPOINT_SYNC_ASYNC,
3533                     .rates = SNDRV_PCM_RATE_48000,
3534                     .rate_min = 48000,
3535                     .rate_max = 48000,
3536                     .nr_rates = 1,
3537                     .rate_table = (unsigned int[]) { 48000 }
3538                     }
3539             },
3540             {
3541                 .ifnum = 0,
3542                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3543                 .data = &(const struct audioformat) {
3544                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3545                     .channels = 8, // inputs
3546                     .iface = 0,
3547                     .altsetting = 1,
3548                     .altset_idx = 1,
3549                     .endpoint = 0x82,
3550                     .ep_idx = 1,
3551                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3552                         USB_ENDPOINT_SYNC_ASYNC|
3553                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3554                     .rates = SNDRV_PCM_RATE_48000,
3555                     .rate_min = 48000,
3556                     .rate_max = 48000,
3557                     .nr_rates = 1,
3558                     .rate_table = (unsigned int[]) { 48000 }
3559                 }
3560             },
3561             {
3562                 .ifnum = -1
3563             }
3564         }
3565     }
3566 },
3567 {
3568     /*
3569      * PIONEER DJ DDJ-RB
3570      * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed
3571      * The feedback for the output is the dummy input.
3572      */
3573     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e),
3574     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3575         .ifnum = QUIRK_ANY_INTERFACE,
3576         .type = QUIRK_COMPOSITE,
3577         .data = (const struct snd_usb_audio_quirk[]) {
3578             {
3579                 .ifnum = 0,
3580                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3581                 .data = &(const struct audioformat) {
3582                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3583                     .channels = 4,
3584                     .iface = 0,
3585                     .altsetting = 1,
3586                     .altset_idx = 1,
3587                     .endpoint = 0x01,
3588                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3589                            USB_ENDPOINT_SYNC_ASYNC,
3590                     .rates = SNDRV_PCM_RATE_44100,
3591                     .rate_min = 44100,
3592                     .rate_max = 44100,
3593                     .nr_rates = 1,
3594                     .rate_table = (unsigned int[]) { 44100 }
3595                 }
3596             },
3597             {
3598                 .ifnum = 0,
3599                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3600                 .data = &(const struct audioformat) {
3601                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3602                     .channels = 2,
3603                     .iface = 0,
3604                     .altsetting = 1,
3605                     .altset_idx = 1,
3606                     .endpoint = 0x82,
3607                     .ep_idx = 1,
3608                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3609                          USB_ENDPOINT_SYNC_ASYNC|
3610                          USB_ENDPOINT_USAGE_IMPLICIT_FB,
3611                     .rates = SNDRV_PCM_RATE_44100,
3612                     .rate_min = 44100,
3613                     .rate_max = 44100,
3614                     .nr_rates = 1,
3615                     .rate_table = (unsigned int[]) { 44100 }
3616                 }
3617             },
3618             {
3619                 .ifnum = -1
3620             }
3621         }
3622     }
3623 },
3624
3625 {
3626     /*
3627      * PIONEER DJ DDJ-RR
3628      * PCM is 6 channels out & 4 channels in @ 44.1 fixed
3629      */
3630     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000d),
3631     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3632         .ifnum = QUIRK_ANY_INTERFACE,
3633         .type = QUIRK_COMPOSITE,
3634         .data = (const struct snd_usb_audio_quirk[]) {
3635             {
3636                 .ifnum = 0,
3637                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3638                 .data = &(const struct audioformat) {
3639                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3640                     .channels = 6, //Master, Headphones & Booth
3641                     .iface = 0,
3642                     .altsetting = 1,
3643                     .altset_idx = 1,
3644                     .endpoint = 0x01,
3645                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3646                            USB_ENDPOINT_SYNC_ASYNC,
3647                     .rates = SNDRV_PCM_RATE_44100,
3648                     .rate_min = 44100,
3649                     .rate_max = 44100,
3650                     .nr_rates = 1,
3651                     .rate_table = (unsigned int[]) { 44100 }
3652                 }
3653             },
3654             {
3655                 .ifnum = 0,
3656                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3657                 .data = &(const struct audioformat) {
3658                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3659                     .channels = 4, //2x RCA inputs (CH1 & CH2)
3660                     .iface = 0,
3661                     .altsetting = 1,
3662                     .altset_idx = 1,
3663                     .endpoint = 0x82,
3664                     .ep_idx = 1,
3665                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3666                          USB_ENDPOINT_SYNC_ASYNC|
3667                          USB_ENDPOINT_USAGE_IMPLICIT_FB,
3668                     .rates = SNDRV_PCM_RATE_44100,
3669                     .rate_min = 44100,
3670                     .rate_max = 44100,
3671                     .nr_rates = 1,
3672                     .rate_table = (unsigned int[]) { 44100 }
3673                 }
3674             },
3675             {
3676                 .ifnum = -1
3677             }
3678         }
3679     }
3680 },
3681
3682 {
3683     /*
3684      * PIONEER DJ DDJ-SR2
3685      * PCM is 4 channels out, 6 channels in @ 44.1 fixed
3686      * The Feedback for the output is the input
3687      */
3688     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001e),
3689         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3690         .ifnum = QUIRK_ANY_INTERFACE,
3691         .type = QUIRK_COMPOSITE,
3692         .data = (const struct snd_usb_audio_quirk[]) {
3693             {
3694                 .ifnum = 0,
3695                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3696                 .data = &(const struct audioformat) {
3697                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3698                     .channels = 4,
3699                     .iface = 0,
3700                     .altsetting = 1,
3701                     .altset_idx = 1,
3702                     .endpoint = 0x01,
3703                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3704                         USB_ENDPOINT_SYNC_ASYNC,
3705                     .rates = SNDRV_PCM_RATE_44100,
3706                     .rate_min = 44100,
3707                     .rate_max = 44100,
3708                     .nr_rates = 1,
3709                     .rate_table = (unsigned int[]) { 44100 }
3710                 }
3711             },
3712             {
3713                 .ifnum = 0,
3714                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3715                 .data = &(const struct audioformat) {
3716                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3717                     .channels = 6,
3718                     .iface = 0,
3719                     .altsetting = 1,
3720                     .altset_idx = 1,
3721                     .endpoint = 0x82,
3722                     .ep_idx = 1,
3723                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3724                         USB_ENDPOINT_SYNC_ASYNC|
3725                     USB_ENDPOINT_USAGE_IMPLICIT_FB,
3726                     .rates = SNDRV_PCM_RATE_44100,
3727                     .rate_min = 44100,
3728                     .rate_max = 44100,
3729                     .nr_rates = 1,
3730                     .rate_table = (unsigned int[]) { 44100 }
3731                 }
3732             },
3733             {
3734                 .ifnum = -1
3735             }
3736         }
3737     }
3738 },
3739
3740 {
3741     /*
3742      * Pioneer DJ DJM-900NXS2
3743      * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE
3744      */
3745     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a),
3746     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3747         .ifnum = QUIRK_ANY_INTERFACE,
3748         .type = QUIRK_COMPOSITE,
3749         .data = (const struct snd_usb_audio_quirk[]) {
3750             {
3751                 .ifnum = 0,
3752                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3753                 .data = &(const struct audioformat) {
3754                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3755                     .channels = 10,
3756                     .iface = 0,
3757                     .altsetting = 1,
3758                     .altset_idx = 1,
3759                     .endpoint = 0x01,
3760                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3761                         USB_ENDPOINT_SYNC_ASYNC,
3762                     .rates = SNDRV_PCM_RATE_44100|
3763                         SNDRV_PCM_RATE_48000|
3764                         SNDRV_PCM_RATE_96000,
3765                     .rate_min = 44100,
3766                     .rate_max = 96000,
3767                     .nr_rates = 3,
3768                     .rate_table = (unsigned int[]) {
3769                         44100, 48000, 96000
3770                     }
3771                 }
3772             },
3773             {
3774                 .ifnum = 0,
3775                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3776                 .data = &(const struct audioformat) {
3777                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3778                     .channels = 12,
3779                     .iface = 0,
3780                     .altsetting = 1,
3781                     .altset_idx = 1,
3782                     .endpoint = 0x82,
3783                     .ep_idx = 1,
3784                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3785                         USB_ENDPOINT_SYNC_ASYNC|
3786                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3787                     .rates = SNDRV_PCM_RATE_44100|
3788                         SNDRV_PCM_RATE_48000|
3789                         SNDRV_PCM_RATE_96000,
3790                     .rate_min = 44100,
3791                     .rate_max = 96000,
3792                     .nr_rates = 3,
3793                     .rate_table = (unsigned int[]) {
3794                         44100, 48000, 96000
3795                     }
3796                 }
3797             },
3798             {
3799                 .ifnum = -1
3800             }
3801         }
3802     }
3803 },
3804
3805 /*
3806  * MacroSilicon MS2100/MS2106 based AV capture cards
3807  *
3808  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3809  * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
3810  * they pretend to be 96kHz mono as a workaround for stereo being broken
3811  * by that...
3812  *
3813  * They also have an issue with initial stream alignment that causes the
3814  * channels to be swapped and out of phase, which is dealt with in quirks.c.
3815  */
3816 {
3817     USB_AUDIO_DEVICE(0x534d, 0x0021),
3818     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3819         .vendor_name = "MacroSilicon",
3820         .product_name = "MS210x",
3821         .ifnum = QUIRK_ANY_INTERFACE,
3822         .type = QUIRK_COMPOSITE,
3823         .data = &(const struct snd_usb_audio_quirk[]) {
3824             {
3825                 .ifnum = 2,
3826                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3827             },
3828             {
3829                 .ifnum = 3,
3830                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3831                 .data = &(const struct audioformat) {
3832                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
3833                     .channels = 2,
3834                     .iface = 3,
3835                     .altsetting = 1,
3836                     .altset_idx = 1,
3837                     .attributes = 0,
3838                     .endpoint = 0x82,
3839                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
3840                         USB_ENDPOINT_SYNC_ASYNC,
3841                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
3842                     .rate_min = 48000,
3843                     .rate_max = 48000,
3844                 }
3845             },
3846             {
3847                 .ifnum = -1
3848             }
3849         }
3850     }
3851 },
3852
3853 /*
3854  * MacroSilicon MS2109 based HDMI capture cards
3855  *
3856  * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch.
3857  * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if
3858  * they pretend to be 96kHz mono as a workaround for stereo being broken
3859  * by that...
3860  *
3861  * They also have an issue with initial stream alignment that causes the
3862  * channels to be swapped and out of phase, which is dealt with in quirks.c.
3863  */
3864 {
3865     USB_AUDIO_DEVICE(0x534d, 0x2109),
3866     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3867         .vendor_name = "MacroSilicon",
3868         .product_name = "MS2109",
3869         .ifnum = QUIRK_ANY_INTERFACE,
3870         .type = QUIRK_COMPOSITE,
3871         .data = &(const struct snd_usb_audio_quirk[]) {
3872             {
3873                 .ifnum = 2,
3874                 .type = QUIRK_AUDIO_STANDARD_MIXER,
3875             },
3876             {
3877                 .ifnum = 3,
3878                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3879                 .data = &(const struct audioformat) {
3880                     .formats = SNDRV_PCM_FMTBIT_S16_LE,
3881                     .channels = 2,
3882                     .iface = 3,
3883                     .altsetting = 1,
3884                     .altset_idx = 1,
3885                     .attributes = 0,
3886                     .endpoint = 0x82,
3887                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
3888                         USB_ENDPOINT_SYNC_ASYNC,
3889                     .rates = SNDRV_PCM_RATE_CONTINUOUS,
3890                     .rate_min = 48000,
3891                     .rate_max = 48000,
3892                 }
3893             },
3894             {
3895                 .ifnum = -1
3896             }
3897         }
3898     }
3899 },
3900 {
3901     /*
3902      * Pioneer DJ DJM-750
3903      * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE
3904      */
3905     USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f),
3906     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3907         .ifnum = QUIRK_ANY_INTERFACE,
3908         .type = QUIRK_COMPOSITE,
3909         .data = (const struct snd_usb_audio_quirk[]) {
3910             {
3911                 .ifnum = 0,
3912                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3913                 .data = &(const struct audioformat) {
3914                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3915                     .channels = 8,
3916                     .iface = 0,
3917                     .altsetting = 1,
3918                     .altset_idx = 1,
3919                     .endpoint = 0x05,
3920                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3921                         USB_ENDPOINT_SYNC_ASYNC,
3922                     .rates = SNDRV_PCM_RATE_44100|
3923                         SNDRV_PCM_RATE_48000|
3924                         SNDRV_PCM_RATE_96000,
3925                     .rate_min = 44100,
3926                     .rate_max = 96000,
3927                     .nr_rates = 3,
3928                     .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3929                 }
3930             },
3931             {
3932                 .ifnum = 0,
3933                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3934                 .data = &(const struct audioformat) {
3935                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3936                     .channels = 8,
3937                     .iface = 0,
3938                     .altsetting = 1,
3939                     .altset_idx = 1,
3940                     .endpoint = 0x86,
3941                     .ep_idx = 1,
3942                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3943                         USB_ENDPOINT_SYNC_ASYNC|
3944                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
3945                     .rates = SNDRV_PCM_RATE_44100|
3946                         SNDRV_PCM_RATE_48000|
3947                         SNDRV_PCM_RATE_96000,
3948                     .rate_min = 44100,
3949                     .rate_max = 96000,
3950                     .nr_rates = 3,
3951                     .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
3952                 }
3953             },
3954             {
3955                 .ifnum = -1
3956             }
3957         }
3958     }
3959 },
3960 {
3961     /*
3962      * Pioneer DJ DJM-750MK2
3963      * 10 channels playback & 12 channels capture @ 48kHz S24LE
3964      */
3965     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001b),
3966     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
3967         .ifnum = QUIRK_ANY_INTERFACE,
3968         .type = QUIRK_COMPOSITE,
3969         .data = (const struct snd_usb_audio_quirk[]) {
3970             {
3971                 .ifnum = 0,
3972                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3973                 .data = &(const struct audioformat) {
3974                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3975                     .channels = 10,
3976                     .iface = 0,
3977                     .altsetting = 1,
3978                     .altset_idx = 1,
3979                     .endpoint = 0x01,
3980                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
3981                         USB_ENDPOINT_SYNC_ASYNC,
3982                     .rates = SNDRV_PCM_RATE_48000,
3983                     .rate_min = 48000,
3984                     .rate_max = 48000,
3985                     .nr_rates = 1,
3986                     .rate_table = (unsigned int[]) {
3987                         48000
3988                     }
3989                 }
3990             },
3991             {
3992                 .ifnum = 0,
3993                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3994                 .data = &(const struct audioformat) {
3995                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3996                     .channels = 12,
3997                     .iface = 0,
3998                     .altsetting = 1,
3999                     .altset_idx = 1,
4000                     .endpoint = 0x82,
4001                     .ep_idx = 1,
4002                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
4003                         USB_ENDPOINT_SYNC_ASYNC|
4004                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
4005                     .rates = SNDRV_PCM_RATE_48000,
4006                     .rate_min = 48000,
4007                     .rate_max = 48000,
4008                     .nr_rates = 1,
4009                     .rate_table = (unsigned int[]) { 48000 }
4010                 }
4011             },
4012             {
4013                 .ifnum = -1
4014             }
4015         }
4016     }
4017 },
4018 {
4019     /*
4020      * Pioneer DJ DJM-850
4021      * 8 channels playback and 8 channels capture @ 44.1/48/96kHz S24LE
4022      * Playback on EP 0x05
4023      * Capture on EP 0x86
4024      */
4025     USB_DEVICE_VENDOR_SPEC(0x08e4, 0x0163),
4026     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4027         .ifnum = QUIRK_ANY_INTERFACE,
4028         .type = QUIRK_COMPOSITE,
4029         .data = (const struct snd_usb_audio_quirk[]) {
4030             {
4031                 .ifnum = 0,
4032                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4033                 .data = &(const struct audioformat) {
4034                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4035                     .channels = 8,
4036                     .iface = 0,
4037                     .altsetting = 1,
4038                     .altset_idx = 1,
4039                     .endpoint = 0x05,
4040                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
4041                         USB_ENDPOINT_SYNC_ASYNC|
4042                         USB_ENDPOINT_USAGE_DATA,
4043                     .rates = SNDRV_PCM_RATE_44100|
4044                         SNDRV_PCM_RATE_48000|
4045                         SNDRV_PCM_RATE_96000,
4046                     .rate_min = 44100,
4047                     .rate_max = 96000,
4048                     .nr_rates = 3,
4049                     .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4050                 }
4051             },
4052             {
4053                 .ifnum = 0,
4054                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4055                 .data = &(const struct audioformat) {
4056                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4057                     .channels = 8,
4058                     .iface = 0,
4059                     .altsetting = 1,
4060                     .altset_idx = 1,
4061                     .endpoint = 0x86,
4062                     .ep_idx = 1,
4063                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
4064                         USB_ENDPOINT_SYNC_ASYNC|
4065                         USB_ENDPOINT_USAGE_DATA,
4066                     .rates = SNDRV_PCM_RATE_44100|
4067                         SNDRV_PCM_RATE_48000|
4068                         SNDRV_PCM_RATE_96000,
4069                     .rate_min = 44100,
4070                     .rate_max = 96000,
4071                     .nr_rates = 3,
4072                     .rate_table = (unsigned int[]) { 44100, 48000, 96000 }
4073                 }
4074             },
4075             {
4076                 .ifnum = -1
4077             }
4078         }
4079     }
4080 },
4081 {
4082     /*
4083      * Pioneer DJ DJM-450
4084      * PCM is 8 channels out @ 48 fixed (endpoint 0x01)
4085      * and 8 channels in @ 48 fixed (endpoint 0x82).
4086      */
4087     USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013),
4088     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4089         .ifnum = QUIRK_ANY_INTERFACE,
4090         .type = QUIRK_COMPOSITE,
4091         .data = (const struct snd_usb_audio_quirk[]) {
4092             {
4093                 .ifnum = 0,
4094                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4095                 .data = &(const struct audioformat) {
4096                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4097                     .channels = 8, // outputs
4098                     .iface = 0,
4099                     .altsetting = 1,
4100                     .altset_idx = 1,
4101                     .endpoint = 0x01,
4102                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
4103                         USB_ENDPOINT_SYNC_ASYNC,
4104                     .rates = SNDRV_PCM_RATE_48000,
4105                     .rate_min = 48000,
4106                     .rate_max = 48000,
4107                     .nr_rates = 1,
4108                     .rate_table = (unsigned int[]) { 48000 }
4109                     }
4110             },
4111             {
4112                 .ifnum = 0,
4113                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4114                 .data = &(const struct audioformat) {
4115                     .formats = SNDRV_PCM_FMTBIT_S24_3LE,
4116                     .channels = 8, // inputs
4117                     .iface = 0,
4118                     .altsetting = 1,
4119                     .altset_idx = 1,
4120                     .endpoint = 0x82,
4121                     .ep_idx = 1,
4122                     .ep_attr = USB_ENDPOINT_XFER_ISOC|
4123                         USB_ENDPOINT_SYNC_ASYNC|
4124                         USB_ENDPOINT_USAGE_IMPLICIT_FB,
4125                     .rates = SNDRV_PCM_RATE_48000,
4126                     .rate_min = 48000,
4127                     .rate_max = 48000,
4128                     .nr_rates = 1,
4129                     .rate_table = (unsigned int[]) { 48000 }
4130                 }
4131             },
4132             {
4133                 .ifnum = -1
4134             }
4135         }
4136     }
4137 },
4138 {
4139     /*
4140      * Sennheiser GSP670
4141      * Change order of interfaces loaded
4142      */
4143     USB_DEVICE(0x1395, 0x0300),
4144     .bInterfaceClass = USB_CLASS_PER_INTERFACE,
4145     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4146         .ifnum = QUIRK_ANY_INTERFACE,
4147         .type = QUIRK_COMPOSITE,
4148         .data = &(const struct snd_usb_audio_quirk[]) {
4149             // Communication
4150             {
4151                 .ifnum = 3,
4152                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4153             },
4154             // Recording
4155             {
4156                 .ifnum = 4,
4157                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4158             },
4159             // Main
4160             {
4161                 .ifnum = 1,
4162                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4163             },
4164             {
4165                 .ifnum = -1
4166             }
4167         }
4168     }
4169 },
4170 {
4171     /*
4172      * Fiero SC-01 (firmware v1.0.0 @ 48 kHz)
4173      */
4174     USB_DEVICE(0x2b53, 0x0023),
4175     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4176         .vendor_name = "Fiero",
4177         .product_name = "SC-01",
4178         .ifnum = QUIRK_ANY_INTERFACE,
4179         .type = QUIRK_COMPOSITE,
4180         .data = &(const struct snd_usb_audio_quirk[]) {
4181             {
4182                 .ifnum = 0,
4183                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4184             },
4185             /* Playback */
4186             {
4187                 .ifnum = 1,
4188                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4189                 .data = &(const struct audioformat) {
4190                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
4191                     .channels = 2,
4192                     .fmt_bits = 24,
4193                     .iface = 1,
4194                     .altsetting = 1,
4195                     .altset_idx = 1,
4196                     .endpoint = 0x01,
4197                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
4198                            USB_ENDPOINT_SYNC_ASYNC,
4199                     .rates = SNDRV_PCM_RATE_48000,
4200                     .rate_min = 48000,
4201                     .rate_max = 48000,
4202                     .nr_rates = 1,
4203                     .rate_table = (unsigned int[]) { 48000 },
4204                     .clock = 0x29
4205                 }
4206             },
4207             /* Capture */
4208             {
4209                 .ifnum = 2,
4210                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4211                 .data = &(const struct audioformat) {
4212                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
4213                     .channels = 2,
4214                     .fmt_bits = 24,
4215                     .iface = 2,
4216                     .altsetting = 1,
4217                     .altset_idx = 1,
4218                     .endpoint = 0x82,
4219                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
4220                            USB_ENDPOINT_SYNC_ASYNC |
4221                            USB_ENDPOINT_USAGE_IMPLICIT_FB,
4222                     .rates = SNDRV_PCM_RATE_48000,
4223                     .rate_min = 48000,
4224                     .rate_max = 48000,
4225                     .nr_rates = 1,
4226                     .rate_table = (unsigned int[]) { 48000 },
4227                     .clock = 0x29
4228                 }
4229             },
4230             {
4231                 .ifnum = -1
4232             }
4233         }
4234     }
4235 },
4236 {
4237     /*
4238      * Fiero SC-01 (firmware v1.0.0 @ 96 kHz)
4239      */
4240     USB_DEVICE(0x2b53, 0x0024),
4241     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4242         .vendor_name = "Fiero",
4243         .product_name = "SC-01",
4244         .ifnum = QUIRK_ANY_INTERFACE,
4245         .type = QUIRK_COMPOSITE,
4246         .data = &(const struct snd_usb_audio_quirk[]) {
4247             {
4248                 .ifnum = 0,
4249                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4250             },
4251             /* Playback */
4252             {
4253                 .ifnum = 1,
4254                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4255                 .data = &(const struct audioformat) {
4256                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
4257                     .channels = 2,
4258                     .fmt_bits = 24,
4259                     .iface = 1,
4260                     .altsetting = 1,
4261                     .altset_idx = 1,
4262                     .endpoint = 0x01,
4263                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
4264                            USB_ENDPOINT_SYNC_ASYNC,
4265                     .rates = SNDRV_PCM_RATE_96000,
4266                     .rate_min = 96000,
4267                     .rate_max = 96000,
4268                     .nr_rates = 1,
4269                     .rate_table = (unsigned int[]) { 96000 },
4270                     .clock = 0x29
4271                 }
4272             },
4273             /* Capture */
4274             {
4275                 .ifnum = 2,
4276                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4277                 .data = &(const struct audioformat) {
4278                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
4279                     .channels = 2,
4280                     .fmt_bits = 24,
4281                     .iface = 2,
4282                     .altsetting = 1,
4283                     .altset_idx = 1,
4284                     .endpoint = 0x82,
4285                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
4286                            USB_ENDPOINT_SYNC_ASYNC |
4287                            USB_ENDPOINT_USAGE_IMPLICIT_FB,
4288                     .rates = SNDRV_PCM_RATE_96000,
4289                     .rate_min = 96000,
4290                     .rate_max = 96000,
4291                     .nr_rates = 1,
4292                     .rate_table = (unsigned int[]) { 96000 },
4293                     .clock = 0x29
4294                 }
4295             },
4296             {
4297                 .ifnum = -1
4298             }
4299         }
4300     }
4301 },
4302 {
4303     /*
4304      * Fiero SC-01 (firmware v1.1.0)
4305      */
4306     USB_DEVICE(0x2b53, 0x0031),
4307     .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
4308         .vendor_name = "Fiero",
4309         .product_name = "SC-01",
4310         .ifnum = QUIRK_ANY_INTERFACE,
4311         .type = QUIRK_COMPOSITE,
4312         .data = &(const struct snd_usb_audio_quirk[]) {
4313             {
4314                 .ifnum = 0,
4315                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
4316             },
4317             /* Playback */
4318             {
4319                 .ifnum = 1,
4320                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4321                 .data = &(const struct audioformat) {
4322                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
4323                     .channels = 2,
4324                     .fmt_bits = 24,
4325                     .iface = 1,
4326                     .altsetting = 1,
4327                     .altset_idx = 1,
4328                     .endpoint = 0x01,
4329                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
4330                            USB_ENDPOINT_SYNC_ASYNC,
4331                     .rates = SNDRV_PCM_RATE_48000 |
4332                          SNDRV_PCM_RATE_96000,
4333                     .rate_min = 48000,
4334                     .rate_max = 96000,
4335                     .nr_rates = 2,
4336                     .rate_table = (unsigned int[]) { 48000, 96000 },
4337                     .clock = 0x29
4338                 }
4339             },
4340             /* Capture */
4341             {
4342                 .ifnum = 2,
4343                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
4344                 .data = &(const struct audioformat) {
4345                     .formats = SNDRV_PCM_FMTBIT_S32_LE,
4346                     .channels = 2,
4347                     .fmt_bits = 24,
4348                     .iface = 2,
4349                     .altsetting = 1,
4350                     .altset_idx = 1,
4351                     .endpoint = 0x82,
4352                     .ep_attr = USB_ENDPOINT_XFER_ISOC |
4353                            USB_ENDPOINT_SYNC_ASYNC |
4354                            USB_ENDPOINT_USAGE_IMPLICIT_FB,
4355                     .rates = SNDRV_PCM_RATE_48000 |
4356                          SNDRV_PCM_RATE_96000,
4357                     .rate_min = 48000,
4358                     .rate_max = 96000,
4359                     .nr_rates = 2,
4360                     .rate_table = (unsigned int[]) { 48000, 96000 },
4361                     .clock = 0x29
4362                 }
4363             },
4364             {
4365                 .ifnum = -1
4366             }
4367         }
4368     }
4369 },
4370
4371 #undef USB_DEVICE_VENDOR_SPEC
4372 #undef USB_AUDIO_DEVICE