sound/usb/quirks-table.h

   1 /*
   2  * ALSA USB Audio Driver
   3  *
   4  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   5  *                       Clemens Ladisch <clemens@ladisch.de>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 /*
  24  * The contents of this file are part of the driver's id_table.
  25  *
  26  * In a perfect world, this file would be empty.
  27  */
  28
  29 /*
  30  * Use this for devices where other interfaces are standard compliant,
  31  * to prevent the quirk being applied to those interfaces. (To work with
  32  * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  33  */
  34 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  35         .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  36                        USB_DEVICE_ID_MATCH_PRODUCT | \
  37                        USB_DEVICE_ID_MATCH_INT_CLASS, \
  38         .idVendor = vend, \
  39         .idProduct = prod, \
  40         .bInterfaceClass = USB_CLASS_VENDOR_SPEC
  41
  42 /* Creative/Toshiba Multimedia Center SB-0500 */
  43 {
  44         USB_DEVICE(0x041e, 0x3048),
  45         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  46                 .vendor_name = "Toshiba",
  47                 .product_name = "SB-0500",
  48                 .ifnum = QUIRK_NO_INTERFACE
  49         }
  50 },
  51
  52 /* Creative/E-Mu devices */
  53 {
  54         USB_DEVICE(0x041e, 0x3010),
  55         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  56                 .vendor_name = "Creative Labs",
  57                 .product_name = "Sound Blaster MP3+",
  58                 .ifnum = QUIRK_NO_INTERFACE
  59         }
  60 },
  61 {
  62         /* E-Mu 0202 USB */
  63         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  64         .idVendor = 0x041e,
  65         .idProduct = 0x3f02,
  66         .bInterfaceClass = USB_CLASS_AUDIO,
  67 },
  68 {
  69         /* E-Mu 0404 USB */
  70         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  71         .idVendor = 0x041e,
  72         .idProduct = 0x3f04,
  73         .bInterfaceClass = USB_CLASS_AUDIO,
  74 },
  75 {
  76         /* E-Mu Tracker Pre */
  77         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  78         .idVendor = 0x041e,
  79         .idProduct = 0x3f0a,
  80         .bInterfaceClass = USB_CLASS_AUDIO,
  81 },
  82 {
  83         /* E-Mu 0204 USB */
  84         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  85         .idVendor = 0x041e,
  86         .idProduct = 0x3f19,
  87         .bInterfaceClass = USB_CLASS_AUDIO,
  88 },
  89
  90 /*
  91  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
  92  * class matches do not take effect without an explicit ID match.
  93  */
  94 {
  95         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  96                        USB_DEVICE_ID_MATCH_INT_CLASS |
  97                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  98         .idVendor = 0x046d,
  99         .idProduct = 0x0850,
 100         .bInterfaceClass = USB_CLASS_AUDIO,
 101         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 102 },
 103 {
 104         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 105                        USB_DEVICE_ID_MATCH_INT_CLASS |
 106                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 107         .idVendor = 0x046d,
 108         .idProduct = 0x08ae,
 109         .bInterfaceClass = USB_CLASS_AUDIO,
 110         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 111 },
 112 {
 113         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 114                        USB_DEVICE_ID_MATCH_INT_CLASS |
 115                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 116         .idVendor = 0x046d,
 117         .idProduct = 0x08c6,
 118         .bInterfaceClass = USB_CLASS_AUDIO,
 119         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 120 },
 121 {
 122         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 123                        USB_DEVICE_ID_MATCH_INT_CLASS |
 124                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 125         .idVendor = 0x046d,
 126         .idProduct = 0x08f0,
 127         .bInterfaceClass = USB_CLASS_AUDIO,
 128         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 129 },
 130 {
 131         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 132                        USB_DEVICE_ID_MATCH_INT_CLASS |
 133                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 134         .idVendor = 0x046d,
 135         .idProduct = 0x08f5,
 136         .bInterfaceClass = USB_CLASS_AUDIO,
 137         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 138 },
 139 {
 140         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 141                        USB_DEVICE_ID_MATCH_INT_CLASS |
 142                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 143         .idVendor = 0x046d,
 144         .idProduct = 0x08f6,
 145         .bInterfaceClass = USB_CLASS_AUDIO,
 146         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 147 },
 148 {
 149         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 150                        USB_DEVICE_ID_MATCH_INT_CLASS |
 151                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 152         .idVendor = 0x046d,
 153         .idProduct = 0x0990,
 154         .bInterfaceClass = USB_CLASS_AUDIO,
 155         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 156         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 157                 .vendor_name = "Logitech, Inc.",
 158                 .product_name = "QuickCam Pro 9000",
 159                 .ifnum = QUIRK_NO_INTERFACE
 160         }
 161 },
 162
 163 /*
 164  * Yamaha devices
 165  */
 166
 167 #define YAMAHA_DEVICE(id, name) { \
 168         USB_DEVICE(0x0499, id), \
 169         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 170                 .vendor_name = "Yamaha", \
 171                 .product_name = name, \
 172                 .ifnum = QUIRK_ANY_INTERFACE, \
 173                 .type = QUIRK_MIDI_YAMAHA \
 174         } \
 175 }
 176 #define YAMAHA_INTERFACE(id, intf, name) { \
 177         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 178         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 179                 .vendor_name = "Yamaha", \
 180                 .product_name = name, \
 181                 .ifnum = intf, \
 182                 .type = QUIRK_MIDI_YAMAHA \
 183         } \
 184 }
 185 YAMAHA_DEVICE(0x1000, "UX256"),
 186 YAMAHA_DEVICE(0x1001, "MU1000"),
 187 YAMAHA_DEVICE(0x1002, "MU2000"),
 188 YAMAHA_DEVICE(0x1003, "MU500"),
 189 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 190 YAMAHA_DEVICE(0x1005, "MOTIF6"),
 191 YAMAHA_DEVICE(0x1006, "MOTIF7"),
 192 YAMAHA_DEVICE(0x1007, "MOTIF8"),
 193 YAMAHA_DEVICE(0x1008, "UX96"),
 194 YAMAHA_DEVICE(0x1009, "UX16"),
 195 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 196 YAMAHA_DEVICE(0x100c, "UC-MX"),
 197 YAMAHA_DEVICE(0x100d, "UC-KX"),
 198 YAMAHA_DEVICE(0x100e, "S08"),
 199 YAMAHA_DEVICE(0x100f, "CLP-150"),
 200 YAMAHA_DEVICE(0x1010, "CLP-170"),
 201 YAMAHA_DEVICE(0x1011, "P-250"),
 202 YAMAHA_DEVICE(0x1012, "TYROS"),
 203 YAMAHA_DEVICE(0x1013, "PF-500"),
 204 YAMAHA_DEVICE(0x1014, "S90"),
 205 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 206 YAMAHA_DEVICE(0x1016, "MDP-5"),
 207 YAMAHA_DEVICE(0x1017, "CVP-204"),
 208 YAMAHA_DEVICE(0x1018, "CVP-206"),
 209 YAMAHA_DEVICE(0x1019, "CVP-208"),
 210 YAMAHA_DEVICE(0x101a, "CVP-210"),
 211 YAMAHA_DEVICE(0x101b, "PSR-1100"),
 212 YAMAHA_DEVICE(0x101c, "PSR-2100"),
 213 YAMAHA_DEVICE(0x101d, "CLP-175"),
 214 YAMAHA_DEVICE(0x101e, "PSR-K1"),
 215 YAMAHA_DEVICE(0x101f, "EZ-J24"),
 216 YAMAHA_DEVICE(0x1020, "EZ-250i"),
 217 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 218 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 219 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 220 YAMAHA_DEVICE(0x1024, "CVP-301"),
 221 YAMAHA_DEVICE(0x1025, "CVP-303"),
 222 YAMAHA_DEVICE(0x1026, "CVP-305"),
 223 YAMAHA_DEVICE(0x1027, "CVP-307"),
 224 YAMAHA_DEVICE(0x1028, "CVP-309"),
 225 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 226 YAMAHA_DEVICE(0x102a, "PSR-1500"),
 227 YAMAHA_DEVICE(0x102b, "PSR-3000"),
 228 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 229 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 230 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 231 YAMAHA_DEVICE(0x1032, "DGX-305"),
 232 YAMAHA_DEVICE(0x1033, "DGX-505"),
 233 YAMAHA_DEVICE(0x1034, NULL),
 234 YAMAHA_DEVICE(0x1035, NULL),
 235 YAMAHA_DEVICE(0x1036, NULL),
 236 YAMAHA_DEVICE(0x1037, NULL),
 237 YAMAHA_DEVICE(0x1038, NULL),
 238 YAMAHA_DEVICE(0x1039, NULL),
 239 YAMAHA_DEVICE(0x103a, NULL),
 240 YAMAHA_DEVICE(0x103b, NULL),
 241 YAMAHA_DEVICE(0x103c, NULL),
 242 YAMAHA_DEVICE(0x103d, NULL),
 243 YAMAHA_DEVICE(0x103e, NULL),
 244 YAMAHA_DEVICE(0x103f, NULL),
 245 YAMAHA_DEVICE(0x1040, NULL),
 246 YAMAHA_DEVICE(0x1041, NULL),
 247 YAMAHA_DEVICE(0x1042, NULL),
 248 YAMAHA_DEVICE(0x1043, NULL),
 249 YAMAHA_DEVICE(0x1044, NULL),
 250 YAMAHA_DEVICE(0x1045, NULL),
 251 YAMAHA_INTERFACE(0x104e, 0, NULL),
 252 YAMAHA_DEVICE(0x104f, NULL),
 253 YAMAHA_DEVICE(0x1050, NULL),
 254 YAMAHA_DEVICE(0x1051, NULL),
 255 YAMAHA_DEVICE(0x1052, NULL),
 256 YAMAHA_INTERFACE(0x1053, 0, NULL),
 257 YAMAHA_INTERFACE(0x1054, 0, NULL),
 258 YAMAHA_DEVICE(0x1055, NULL),
 259 YAMAHA_DEVICE(0x1056, NULL),
 260 YAMAHA_DEVICE(0x1057, NULL),
 261 YAMAHA_DEVICE(0x1058, NULL),
 262 YAMAHA_DEVICE(0x1059, NULL),
 263 YAMAHA_DEVICE(0x105a, NULL),
 264 YAMAHA_DEVICE(0x105b, NULL),
 265 YAMAHA_DEVICE(0x105c, NULL),
 266 YAMAHA_DEVICE(0x105d, NULL),
 267 YAMAHA_DEVICE(0x2000, "DGP-7"),
 268 YAMAHA_DEVICE(0x2001, "DGP-5"),
 269 YAMAHA_DEVICE(0x2002, NULL),
 270 YAMAHA_DEVICE(0x2003, NULL),
 271 YAMAHA_DEVICE(0x5000, "CS1D"),
 272 YAMAHA_DEVICE(0x5001, "DSP1D"),
 273 YAMAHA_DEVICE(0x5002, "DME32"),
 274 YAMAHA_DEVICE(0x5003, "DM2000"),
 275 YAMAHA_DEVICE(0x5004, "02R96"),
 276 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 277 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 278 YAMAHA_DEVICE(0x5007, "DM1000"),
 279 YAMAHA_DEVICE(0x5008, "01V96"),
 280 YAMAHA_DEVICE(0x5009, "SPX2000"),
 281 YAMAHA_DEVICE(0x500a, "PM5D"),
 282 YAMAHA_DEVICE(0x500b, "DME64N"),
 283 YAMAHA_DEVICE(0x500c, "DME24N"),
 284 YAMAHA_DEVICE(0x500d, NULL),
 285 YAMAHA_DEVICE(0x500e, NULL),
 286 YAMAHA_DEVICE(0x500f, NULL),
 287 YAMAHA_DEVICE(0x7000, "DTX"),
 288 YAMAHA_DEVICE(0x7010, "UB99"),
 289 #undef YAMAHA_DEVICE
 290 #undef YAMAHA_INTERFACE
 291
 292 /*
 293  * Roland/RolandED/Edirol/BOSS devices
 294  */
 295 {
 296         USB_DEVICE(0x0582, 0x0000),
 297         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 298                 .vendor_name = "Roland",
 299                 .product_name = "UA-100",
 300                 .ifnum = QUIRK_ANY_INTERFACE,
 301                 .type = QUIRK_COMPOSITE,
 302                 .data = (const struct snd_usb_audio_quirk[]) {
 303                         {
 304                                 .ifnum = 0,
 305                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 306                                 .data = & (const struct audioformat) {
 307                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 308                                         .channels = 4,
 309                                         .iface = 0,
 310                                         .altsetting = 1,
 311                                         .altset_idx = 1,
 312                                         .attributes = 0,
 313                                         .endpoint = 0x01,
 314                                         .ep_attr = 0x09,
 315                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 316                                         .rate_min = 44100,
 317                                         .rate_max = 44100,
 318                                 }
 319                         },
 320                         {
 321                                 .ifnum = 1,
 322                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 323                                 .data = & (const struct audioformat) {
 324                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 325                                         .channels = 2,
 326                                         .iface = 1,
 327                                         .altsetting = 1,
 328                                         .altset_idx = 1,
 329                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX,
 330                                         .endpoint = 0x81,
 331                                         .ep_attr = 0x05,
 332                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 333                                         .rate_min = 44100,
 334                                         .rate_max = 44100,
 335                                 }
 336                         },
 337                         {
 338                                 .ifnum = 2,
 339                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 340                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 341                                         .out_cables = 0x0007,
 342                                         .in_cables  = 0x0007
 343                                 }
 344                         },
 345                         {
 346                                 .ifnum = -1
 347                         }
 348                 }
 349         }
 350 },
 351 {
 352         USB_DEVICE(0x0582, 0x0002),
 353         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 354                 .vendor_name = "EDIROL",
 355                 .product_name = "UM-4",
 356                 .ifnum = QUIRK_ANY_INTERFACE,
 357                 .type = QUIRK_COMPOSITE,
 358                 .data = (const struct snd_usb_audio_quirk[]) {
 359                         {
 360                                 .ifnum = 0,
 361                                 .type = QUIRK_IGNORE_INTERFACE
 362                         },
 363                         {
 364                                 .ifnum = 1,
 365                                 .type = QUIRK_IGNORE_INTERFACE
 366                         },
 367                         {
 368                                 .ifnum = 2,
 369                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 370                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 371                                         .out_cables = 0x000f,
 372                                         .in_cables  = 0x000f
 373                                 }
 374                         },
 375                         {
 376                                 .ifnum = -1
 377                         }
 378                 }
 379         }
 380 },
 381 {
 382         USB_DEVICE(0x0582, 0x0003),
 383         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 384                 .vendor_name = "Roland",
 385                 .product_name = "SC-8850",
 386                 .ifnum = QUIRK_ANY_INTERFACE,
 387                 .type = QUIRK_COMPOSITE,
 388                 .data = (const struct snd_usb_audio_quirk[]) {
 389                         {
 390                                 .ifnum = 0,
 391                                 .type = QUIRK_IGNORE_INTERFACE
 392                         },
 393                         {
 394                                 .ifnum = 1,
 395                                 .type = QUIRK_IGNORE_INTERFACE
 396                         },
 397                         {
 398                                 .ifnum = 2,
 399                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 400                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 401                                         .out_cables = 0x003f,
 402                                         .in_cables  = 0x003f
 403                                 }
 404                         },
 405                         {
 406                                 .ifnum = -1
 407                         }
 408                 }
 409         }
 410 },
 411 {
 412         USB_DEVICE(0x0582, 0x0004),
 413         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 414                 .vendor_name = "Roland",
 415                 .product_name = "U-8",
 416                 .ifnum = QUIRK_ANY_INTERFACE,
 417                 .type = QUIRK_COMPOSITE,
 418                 .data = (const struct snd_usb_audio_quirk[]) {
 419                         {
 420                                 .ifnum = 0,
 421                                 .type = QUIRK_IGNORE_INTERFACE
 422                         },
 423                         {
 424                                 .ifnum = 1,
 425                                 .type = QUIRK_IGNORE_INTERFACE
 426                         },
 427                         {
 428                                 .ifnum = 2,
 429                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 430                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 431                                         .out_cables = 0x0005,
 432                                         .in_cables  = 0x0005
 433                                 }
 434                         },
 435                         {
 436                                 .ifnum = -1
 437                         }
 438                 }
 439         }
 440 },
 441 {
 442         /* Has ID 0x0099 when not in "Advanced Driver" mode.
 443          * The UM-2EX has only one input, but we cannot detect this. */
 444         USB_DEVICE(0x0582, 0x0005),
 445         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 446                 .vendor_name = "EDIROL",
 447                 .product_name = "UM-2",
 448                 .ifnum = QUIRK_ANY_INTERFACE,
 449                 .type = QUIRK_COMPOSITE,
 450                 .data = (const struct snd_usb_audio_quirk[]) {
 451                         {
 452                                 .ifnum = 0,
 453                                 .type = QUIRK_IGNORE_INTERFACE
 454                         },
 455                         {
 456                                 .ifnum = 1,
 457                                 .type = QUIRK_IGNORE_INTERFACE
 458                         },
 459                         {
 460                                 .ifnum = 2,
 461                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 462                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 463                                         .out_cables = 0x0003,
 464                                         .in_cables  = 0x0003
 465                                 }
 466                         },
 467                         {
 468                                 .ifnum = -1
 469                         }
 470                 }
 471         }
 472 },
 473 {
 474         USB_DEVICE(0x0582, 0x0007),
 475         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 476                 .vendor_name = "Roland",
 477                 .product_name = "SC-8820",
 478                 .ifnum = QUIRK_ANY_INTERFACE,
 479                 .type = QUIRK_COMPOSITE,
 480                 .data = (const struct snd_usb_audio_quirk[]) {
 481                         {
 482                                 .ifnum = 0,
 483                                 .type = QUIRK_IGNORE_INTERFACE
 484                         },
 485                         {
 486                                 .ifnum = 1,
 487                                 .type = QUIRK_IGNORE_INTERFACE
 488                         },
 489                         {
 490                                 .ifnum = 2,
 491                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 492                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 493                                         .out_cables = 0x0013,
 494                                         .in_cables  = 0x0013
 495                                 }
 496                         },
 497                         {
 498                                 .ifnum = -1
 499                         }
 500                 }
 501         }
 502 },
 503 {
 504         USB_DEVICE(0x0582, 0x0008),
 505         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 506                 .vendor_name = "Roland",
 507                 .product_name = "PC-300",
 508                 .ifnum = QUIRK_ANY_INTERFACE,
 509                 .type = QUIRK_COMPOSITE,
 510                 .data = (const struct snd_usb_audio_quirk[]) {
 511                         {
 512                                 .ifnum = 0,
 513                                 .type = QUIRK_IGNORE_INTERFACE
 514                         },
 515                         {
 516                                 .ifnum = 1,
 517                                 .type = QUIRK_IGNORE_INTERFACE
 518                         },
 519                         {
 520                                 .ifnum = 2,
 521                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 522                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 523                                         .out_cables = 0x0001,
 524                                         .in_cables  = 0x0001
 525                                 }
 526                         },
 527                         {
 528                                 .ifnum = -1
 529                         }
 530                 }
 531         }
 532 },
 533 {
 534         /* has ID 0x009d when not in "Advanced Driver" mode */
 535         USB_DEVICE(0x0582, 0x0009),
 536         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 537                 .vendor_name = "EDIROL",
 538                 .product_name = "UM-1",
 539                 .ifnum = QUIRK_ANY_INTERFACE,
 540                 .type = QUIRK_COMPOSITE,
 541                 .data = (const struct snd_usb_audio_quirk[]) {
 542                         {
 543                                 .ifnum = 0,
 544                                 .type = QUIRK_IGNORE_INTERFACE
 545                         },
 546                         {
 547                                 .ifnum = 1,
 548                                 .type = QUIRK_IGNORE_INTERFACE
 549                         },
 550                         {
 551                                 .ifnum = 2,
 552                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 553                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 554                                         .out_cables = 0x0001,
 555                                         .in_cables  = 0x0001
 556                                 }
 557                         },
 558                         {
 559                                 .ifnum = -1
 560                         }
 561                 }
 562         }
 563 },
 564 {
 565         USB_DEVICE(0x0582, 0x000b),
 566         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 567                 .vendor_name = "Roland",
 568                 .product_name = "SK-500",
 569                 .ifnum = QUIRK_ANY_INTERFACE,
 570                 .type = QUIRK_COMPOSITE,
 571                 .data = (const struct snd_usb_audio_quirk[]) {
 572                         {
 573                                 .ifnum = 0,
 574                                 .type = QUIRK_IGNORE_INTERFACE
 575                         },
 576                         {
 577                                 .ifnum = 1,
 578                                 .type = QUIRK_IGNORE_INTERFACE
 579                         },
 580                         {
 581                                 .ifnum = 2,
 582                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 583                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 584                                         .out_cables = 0x0013,
 585                                         .in_cables  = 0x0013
 586                                 }
 587                         },
 588                         {
 589                                 .ifnum = -1
 590                         }
 591                 }
 592         }
 593 },
 594 {
 595         /* thanks to Emiliano Grilli <emillo@libero.it>
 596          * for helping researching this data */
 597         USB_DEVICE(0x0582, 0x000c),
 598         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 599                 .vendor_name = "Roland",
 600                 .product_name = "SC-D70",
 601                 .ifnum = QUIRK_ANY_INTERFACE,
 602                 .type = QUIRK_COMPOSITE,
 603                 .data = (const struct snd_usb_audio_quirk[]) {
 604                         {
 605                                 .ifnum = 0,
 606                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 607                                 .data = & (const struct audioformat) {
 608                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 609                                         .channels = 2,
 610                                         .iface = 0,
 611                                         .altsetting = 1,
 612                                         .altset_idx = 1,
 613                                         .attributes = 0,
 614                                         .endpoint = 0x01,
 615                                         .ep_attr = 0x01,
 616                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 617                                         .rate_min = 44100,
 618                                         .rate_max = 44100,
 619                                 }
 620                         },
 621                         {
 622                                 .ifnum = 1,
 623                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 624                                 .data = & (const struct audioformat) {
 625                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 626                                         .channels = 2,
 627                                         .iface = 1,
 628                                         .altsetting = 1,
 629                                         .altset_idx = 1,
 630                                         .attributes = 0,
 631                                         .endpoint = 0x81,
 632                                         .ep_attr = 0x01,
 633                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 634                                         .rate_min = 44100,
 635                                         .rate_max = 44100,
 636                                 }
 637                         },
 638                         {
 639                                 .ifnum = 2,
 640                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 641                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 642                                         .out_cables = 0x0007,
 643                                         .in_cables  = 0x0007
 644                                 }
 645                         },
 646                         {
 647                                 .ifnum = -1
 648                         }
 649                 }
 650         }
 651 },
 652 {       /*
 653          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 654          * If the advanced mode switch at the back of the unit is off, the
 655          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 656          * but offers only 16-bit PCM.
 657          * In advanced mode, the UA-5 will output S24_3LE samples (two
 658          * channels) at the rate indicated on the front switch, including
 659          * the 96kHz sample rate.
 660          */
 661         USB_DEVICE(0x0582, 0x0010),
 662         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 663                 .vendor_name = "EDIROL",
 664                 .product_name = "UA-5",
 665                 .ifnum = QUIRK_ANY_INTERFACE,
 666                 .type = QUIRK_COMPOSITE,
 667                 .data = (const struct snd_usb_audio_quirk[]) {
 668                         {
 669                                 .ifnum = 1,
 670                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 671                         },
 672                         {
 673                                 .ifnum = 2,
 674                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 675                         },
 676                         {
 677                                 .ifnum = -1
 678                         }
 679                 }
 680         }
 681 },
 682 {
 683         /* has ID 0x0013 when not in "Advanced Driver" mode */
 684         USB_DEVICE(0x0582, 0x0012),
 685         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 686                 .vendor_name = "Roland",
 687                 .product_name = "XV-5050",
 688                 .ifnum = 0,
 689                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 690                 .data = & (const struct snd_usb_midi_endpoint_info) {
 691                         .out_cables = 0x0001,
 692                         .in_cables  = 0x0001
 693                 }
 694         }
 695 },
 696 {
 697         /* has ID 0x0015 when not in "Advanced Driver" mode */
 698         USB_DEVICE(0x0582, 0x0014),
 699         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 700                 .vendor_name = "EDIROL",
 701                 .product_name = "UM-880",
 702                 .ifnum = 0,
 703                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 704                 .data = & (const struct snd_usb_midi_endpoint_info) {
 705                         .out_cables = 0x01ff,
 706                         .in_cables  = 0x01ff
 707                 }
 708         }
 709 },
 710 {
 711         /* has ID 0x0017 when not in "Advanced Driver" mode */
 712         USB_DEVICE(0x0582, 0x0016),
 713         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 714                 .vendor_name = "EDIROL",
 715                 .product_name = "SD-90",
 716                 .ifnum = QUIRK_ANY_INTERFACE,
 717                 .type = QUIRK_COMPOSITE,
 718                 .data = (const struct snd_usb_audio_quirk[]) {
 719                         {
 720                                 .ifnum = 0,
 721                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 722                         },
 723                         {
 724                                 .ifnum = 1,
 725                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 726                         },
 727                         {
 728                                 .ifnum = 2,
 729                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 730                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 731                                         .out_cables = 0x000f,
 732                                         .in_cables  = 0x000f
 733                                 }
 734                         },
 735                         {
 736                                 .ifnum = -1
 737                         }
 738                 }
 739         }
 740 },
 741 {
 742         /* has ID 0x001c when not in "Advanced Driver" mode */
 743         USB_DEVICE(0x0582, 0x001b),
 744         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 745                 .vendor_name = "Roland",
 746                 .product_name = "MMP-2",
 747                 .ifnum = QUIRK_ANY_INTERFACE,
 748                 .type = QUIRK_COMPOSITE,
 749                 .data = (const struct snd_usb_audio_quirk[]) {
 750                         {
 751                                 .ifnum = 0,
 752                                 .type = QUIRK_IGNORE_INTERFACE
 753                         },
 754                         {
 755                                 .ifnum = 1,
 756                                 .type = QUIRK_IGNORE_INTERFACE
 757                         },
 758                         {
 759                                 .ifnum = 2,
 760                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 761                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 762                                         .out_cables = 0x0001,
 763                                         .in_cables  = 0x0001
 764                                 }
 765                         },
 766                         {
 767                                 .ifnum = -1
 768                         }
 769                 }
 770         }
 771 },
 772 {
 773         /* has ID 0x001e when not in "Advanced Driver" mode */
 774         USB_DEVICE(0x0582, 0x001d),
 775         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 776                 .vendor_name = "Roland",
 777                 .product_name = "V-SYNTH",
 778                 .ifnum = 0,
 779                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 780                 .data = & (const struct snd_usb_midi_endpoint_info) {
 781                         .out_cables = 0x0001,
 782                         .in_cables  = 0x0001
 783                 }
 784         }
 785 },
 786 {
 787         /* has ID 0x0024 when not in "Advanced Driver" mode */
 788         USB_DEVICE(0x0582, 0x0023),
 789         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 790                 .vendor_name = "EDIROL",
 791                 .product_name = "UM-550",
 792                 .ifnum = 0,
 793                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 794                 .data = & (const struct snd_usb_midi_endpoint_info) {
 795                         .out_cables = 0x003f,
 796                         .in_cables  = 0x003f
 797                 }
 798         }
 799 },
 800 {
 801         /*
 802          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 803          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 804          * and no MIDI.
 805          */
 806         USB_DEVICE(0x0582, 0x0025),
 807         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 808                 .vendor_name = "EDIROL",
 809                 .product_name = "UA-20",
 810                 .ifnum = QUIRK_ANY_INTERFACE,
 811                 .type = QUIRK_COMPOSITE,
 812                 .data = (const struct snd_usb_audio_quirk[]) {
 813                         {
 814                                 .ifnum = 0,
 815                                 .type = QUIRK_IGNORE_INTERFACE
 816                         },
 817                         {
 818                                 .ifnum = 1,
 819                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 820                                 .data = & (const struct audioformat) {
 821                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 822                                         .channels = 2,
 823                                         .iface = 1,
 824                                         .altsetting = 1,
 825                                         .altset_idx = 1,
 826                                         .attributes = 0,
 827                                         .endpoint = 0x01,
 828                                         .ep_attr = 0x01,
 829                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 830                                         .rate_min = 44100,
 831                                         .rate_max = 44100,
 832                                 }
 833                         },
 834                         {
 835                                 .ifnum = 2,
 836                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 837                                 .data = & (const struct audioformat) {
 838                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 839                                         .channels = 2,
 840                                         .iface = 2,
 841                                         .altsetting = 1,
 842                                         .altset_idx = 1,
 843                                         .attributes = 0,
 844                                         .endpoint = 0x82,
 845                                         .ep_attr = 0x01,
 846                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 847                                         .rate_min = 44100,
 848                                         .rate_max = 44100,
 849                                 }
 850                         },
 851                         {
 852                                 .ifnum = 3,
 853                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 854                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 855                                         .out_cables = 0x0001,
 856                                         .in_cables  = 0x0001
 857                                 }
 858                         },
 859                         {
 860                                 .ifnum = -1
 861                         }
 862                 }
 863         }
 864 },
 865 {
 866         /* has ID 0x0028 when not in "Advanced Driver" mode */
 867         USB_DEVICE(0x0582, 0x0027),
 868         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 869                 .vendor_name = "EDIROL",
 870                 .product_name = "SD-20",
 871                 .ifnum = 0,
 872                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 873                 .data = & (const struct snd_usb_midi_endpoint_info) {
 874                         .out_cables = 0x0003,
 875                         .in_cables  = 0x0007
 876                 }
 877         }
 878 },
 879 {
 880         /* has ID 0x002a when not in "Advanced Driver" mode */
 881         USB_DEVICE(0x0582, 0x0029),
 882         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 883                 .vendor_name = "EDIROL",
 884                 .product_name = "SD-80",
 885                 .ifnum = 0,
 886                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 887                 .data = & (const struct snd_usb_midi_endpoint_info) {
 888                         .out_cables = 0x000f,
 889                         .in_cables  = 0x000f
 890                 }
 891         }
 892 },
 893 {       /*
 894          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 895          * If the sample format switch is not in an advanced setting, the
 896          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 897          * but offers only 16-bit PCM and no MIDI.
 898          */
 899         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 900         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 901                 .vendor_name = "EDIROL",
 902                 .product_name = "UA-700",
 903                 .ifnum = QUIRK_ANY_INTERFACE,
 904                 .type = QUIRK_COMPOSITE,
 905                 .data = (const struct snd_usb_audio_quirk[]) {
 906                         {
 907                                 .ifnum = 1,
 908                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 909                         },
 910                         {
 911                                 .ifnum = 2,
 912                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 913                         },
 914                         {
 915                                 .ifnum = 3,
 916                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 917                         },
 918                         {
 919                                 .ifnum = -1
 920                         }
 921                 }
 922         }
 923 },
 924 {
 925         /* has ID 0x002e when not in "Advanced Driver" mode */
 926         USB_DEVICE(0x0582, 0x002d),
 927         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 928                 .vendor_name = "Roland",
 929                 .product_name = "XV-2020",
 930                 .ifnum = 0,
 931                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 932                 .data = & (const struct snd_usb_midi_endpoint_info) {
 933                         .out_cables = 0x0001,
 934                         .in_cables  = 0x0001
 935                 }
 936         }
 937 },
 938 {
 939         /* has ID 0x0030 when not in "Advanced Driver" mode */
 940         USB_DEVICE(0x0582, 0x002f),
 941         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 942                 .vendor_name = "Roland",
 943                 .product_name = "VariOS",
 944                 .ifnum = 0,
 945                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 946                 .data = & (const struct snd_usb_midi_endpoint_info) {
 947                         .out_cables = 0x0007,
 948                         .in_cables  = 0x0007
 949                 }
 950         }
 951 },
 952 {
 953         /* has ID 0x0034 when not in "Advanced Driver" mode */
 954         USB_DEVICE(0x0582, 0x0033),
 955         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 956                 .vendor_name = "EDIROL",
 957                 .product_name = "PCR",
 958                 .ifnum = 0,
 959                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 960                 .data = & (const struct snd_usb_midi_endpoint_info) {
 961                         .out_cables = 0x0003,
 962                         .in_cables  = 0x0007
 963                 }
 964         }
 965 },
 966         /* TODO: add Roland M-1000 support */
 967 {
 968         /*
 969          * Has ID 0x0038 when not in "Advanced Driver" mode;
 970          * later revisions use IDs 0x0054 and 0x00a2.
 971          */
 972         USB_DEVICE(0x0582, 0x0037),
 973         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 974                 .vendor_name = "Roland",
 975                 .product_name = "Digital Piano",
 976                 .ifnum = 0,
 977                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 978                 .data = & (const struct snd_usb_midi_endpoint_info) {
 979                         .out_cables = 0x0001,
 980                         .in_cables  = 0x0001
 981                 }
 982         }
 983 },
 984 {
 985         /*
 986          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
 987          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
 988          * and no MIDI.
 989          */
 990         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 991         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 992                 .vendor_name = "BOSS",
 993                 .product_name = "GS-10",
 994                 .ifnum = QUIRK_ANY_INTERFACE,
 995                 .type = QUIRK_COMPOSITE,
 996                 .data = & (const struct snd_usb_audio_quirk[]) {
 997                         {
 998                                 .ifnum = 1,
 999                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1000                         },
1001                         {
1002                                 .ifnum = 2,
1003                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1004                         },
1005                         {
1006                                 .ifnum = 3,
1007                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1008                         },
1009                         {
1010                                 .ifnum = -1
1011                         }
1012                 }
1013         }
1014 },
1015 {
1016         /* has ID 0x0041 when not in "Advanced Driver" mode */
1017         USB_DEVICE(0x0582, 0x0040),
1018         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1019                 .vendor_name = "Roland",
1020                 .product_name = "GI-20",
1021                 .ifnum = 0,
1022                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1023                 .data = & (const struct snd_usb_midi_endpoint_info) {
1024                         .out_cables = 0x0001,
1025                         .in_cables  = 0x0001
1026                 }
1027         }
1028 },
1029 {
1030         /* has ID 0x0043 when not in "Advanced Driver" mode */
1031         USB_DEVICE(0x0582, 0x0042),
1032         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1033                 .vendor_name = "Roland",
1034                 .product_name = "RS-70",
1035                 .ifnum = 0,
1036                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1037                 .data = & (const struct snd_usb_midi_endpoint_info) {
1038                         .out_cables = 0x0001,
1039                         .in_cables  = 0x0001
1040                 }
1041         }
1042 },
1043 {
1044         /* has ID 0x0049 when not in "Advanced Driver" mode */
1045         USB_DEVICE(0x0582, 0x0047),
1046         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1047                 /* .vendor_name = "EDIROL", */
1048                 /* .product_name = "UR-80", */
1049                 .ifnum = QUIRK_ANY_INTERFACE,
1050                 .type = QUIRK_COMPOSITE,
1051                 .data = (const struct snd_usb_audio_quirk[]) {
1052                         /* in the 96 kHz modes, only interface 1 is there */
1053                         {
1054                                 .ifnum = 1,
1055                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1056                         },
1057                         {
1058                                 .ifnum = 2,
1059                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1060                         },
1061                         {
1062                                 .ifnum = -1
1063                         }
1064                 }
1065         }
1066 },
1067 {
1068         /* has ID 0x004a when not in "Advanced Driver" mode */
1069         USB_DEVICE(0x0582, 0x0048),
1070         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1071                 /* .vendor_name = "EDIROL", */
1072                 /* .product_name = "UR-80", */
1073                 .ifnum = 0,
1074                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1075                 .data = & (const struct snd_usb_midi_endpoint_info) {
1076                         .out_cables = 0x0003,
1077                         .in_cables  = 0x0007
1078                 }
1079         }
1080 },
1081         /* TODO: add Edirol M-100FX support */
1082 {
1083         /* has ID 0x004e when not in "Advanced Driver" mode */
1084         USB_DEVICE(0x0582, 0x004c),
1085         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1086                 .vendor_name = "EDIROL",
1087                 .product_name = "PCR-A",
1088                 .ifnum = QUIRK_ANY_INTERFACE,
1089                 .type = QUIRK_COMPOSITE,
1090                 .data = (const struct snd_usb_audio_quirk[]) {
1091                         {
1092                                 .ifnum = 1,
1093                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1094                         },
1095                         {
1096                                 .ifnum = 2,
1097                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1098                         },
1099                         {
1100                                 .ifnum = -1
1101                         }
1102                 }
1103         }
1104 },
1105 {
1106         /* has ID 0x004f when not in "Advanced Driver" mode */
1107         USB_DEVICE(0x0582, 0x004d),
1108         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1109                 .vendor_name = "EDIROL",
1110                 .product_name = "PCR-A",
1111                 .ifnum = 0,
1112                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1113                 .data = & (const struct snd_usb_midi_endpoint_info) {
1114                         .out_cables = 0x0003,
1115                         .in_cables  = 0x0007
1116                 }
1117         }
1118 },
1119 {
1120         /*
1121          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1122          * is standard compliant, but has only 16-bit PCM.
1123          */
1124         USB_DEVICE(0x0582, 0x0050),
1125         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1126                 .vendor_name = "EDIROL",
1127                 .product_name = "UA-3FX",
1128                 .ifnum = QUIRK_ANY_INTERFACE,
1129                 .type = QUIRK_COMPOSITE,
1130                 .data = (const struct snd_usb_audio_quirk[]) {
1131                         {
1132                                 .ifnum = 1,
1133                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1134                         },
1135                         {
1136                                 .ifnum = 2,
1137                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1138                         },
1139                         {
1140                                 .ifnum = -1
1141                         }
1142                 }
1143         }
1144 },
1145 {
1146         USB_DEVICE(0x0582, 0x0052),
1147         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1148                 .vendor_name = "EDIROL",
1149                 .product_name = "UM-1SX",
1150                 .ifnum = 0,
1151                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1152         }
1153 },
1154 {
1155         USB_DEVICE(0x0582, 0x0060),
1156         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1157                 .vendor_name = "Roland",
1158                 .product_name = "EXR Series",
1159                 .ifnum = 0,
1160                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1161         }
1162 },
1163 {
1164         /* has ID 0x0066 when not in "Advanced Driver" mode */
1165         USB_DEVICE(0x0582, 0x0064),
1166         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1167                 /* .vendor_name = "EDIROL", */
1168                 /* .product_name = "PCR-1", */
1169                 .ifnum = QUIRK_ANY_INTERFACE,
1170                 .type = QUIRK_COMPOSITE,
1171                 .data = (const struct snd_usb_audio_quirk[]) {
1172                         {
1173                                 .ifnum = 1,
1174                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1175                         },
1176                         {
1177                                 .ifnum = 2,
1178                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1179                         },
1180                         {
1181                                 .ifnum = -1
1182                         }
1183                 }
1184         }
1185 },
1186 {
1187         /* has ID 0x0067 when not in "Advanced Driver" mode */
1188         USB_DEVICE(0x0582, 0x0065),
1189         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1190                 /* .vendor_name = "EDIROL", */
1191                 /* .product_name = "PCR-1", */
1192                 .ifnum = 0,
1193                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1194                 .data = & (const struct snd_usb_midi_endpoint_info) {
1195                         .out_cables = 0x0001,
1196                         .in_cables  = 0x0003
1197                 }
1198         }
1199 },
1200 {
1201         /* has ID 0x006b when not in "Advanced Driver" mode */
1202         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1203         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1204                 .vendor_name = "Roland",
1205                 .product_name = "SP-606",
1206                 .ifnum = 3,
1207                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1208                 .data = & (const struct snd_usb_midi_endpoint_info) {
1209                         .out_cables = 0x0001,
1210                         .in_cables  = 0x0001
1211                 }
1212         }
1213 },
1214 {
1215         /* has ID 0x006e when not in "Advanced Driver" mode */
1216         USB_DEVICE(0x0582, 0x006d),
1217         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1218                 .vendor_name = "Roland",
1219                 .product_name = "FANTOM-X",
1220                 .ifnum = 0,
1221                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1222                 .data = & (const struct snd_usb_midi_endpoint_info) {
1223                         .out_cables = 0x0001,
1224                         .in_cables  = 0x0001
1225                 }
1226         }
1227 },
1228 {       /*
1229          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1230          * If the switch is not in an advanced setting, the UA-25 has
1231          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1232          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1233          */
1234         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1235         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1236                 .vendor_name = "EDIROL",
1237                 .product_name = "UA-25",
1238                 .ifnum = QUIRK_ANY_INTERFACE,
1239                 .type = QUIRK_COMPOSITE,
1240                 .data = (const struct snd_usb_audio_quirk[]) {
1241                         {
1242                                 .ifnum = 0,
1243                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1244                         },
1245                         {
1246                                 .ifnum = 1,
1247                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1248                         },
1249                         {
1250                                 .ifnum = 2,
1251                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1252                         },
1253                         {
1254                                 .ifnum = -1
1255                         }
1256                 }
1257         }
1258 },
1259 {
1260         /* has ID 0x0076 when not in "Advanced Driver" mode */
1261         USB_DEVICE(0x0582, 0x0075),
1262         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1263                 .vendor_name = "BOSS",
1264                 .product_name = "DR-880",
1265                 .ifnum = 0,
1266                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1267                 .data = & (const struct snd_usb_midi_endpoint_info) {
1268                         .out_cables = 0x0001,
1269                         .in_cables  = 0x0001
1270                 }
1271         }
1272 },
1273 {
1274         /* has ID 0x007b when not in "Advanced Driver" mode */
1275         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1276         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1277                 .vendor_name = "Roland",
1278                 /* "RD" or "RD-700SX"? */
1279                 .ifnum = 0,
1280                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1281                 .data = & (const struct snd_usb_midi_endpoint_info) {
1282                         .out_cables = 0x0003,
1283                         .in_cables  = 0x0003
1284                 }
1285         }
1286 },
1287 {
1288         /* has ID 0x0081 when not in "Advanced Driver" mode */
1289         USB_DEVICE(0x0582, 0x0080),
1290         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1291                 .vendor_name = "Roland",
1292                 .product_name = "G-70",
1293                 .ifnum = 0,
1294                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1295                 .data = & (const struct snd_usb_midi_endpoint_info) {
1296                         .out_cables = 0x0001,
1297                         .in_cables  = 0x0001
1298                 }
1299         }
1300 },
1301         /* TODO: add Roland V-SYNTH XT support */
1302         /* TODO: add BOSS GT-PRO support */
1303 {
1304         /* has ID 0x008c when not in "Advanced Driver" mode */
1305         USB_DEVICE(0x0582, 0x008b),
1306         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1307                 .vendor_name = "EDIROL",
1308                 .product_name = "PC-50",
1309                 .ifnum = 0,
1310                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1311                 .data = & (const struct snd_usb_midi_endpoint_info) {
1312                         .out_cables = 0x0001,
1313                         .in_cables  = 0x0001
1314                 }
1315         }
1316 },
1317         /* TODO: add Edirol PC-80 support */
1318 {
1319         USB_DEVICE(0x0582, 0x0096),
1320         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1321                 .vendor_name = "EDIROL",
1322                 .product_name = "UA-1EX",
1323                 .ifnum = QUIRK_ANY_INTERFACE,
1324                 .type = QUIRK_COMPOSITE,
1325                 .data = (const struct snd_usb_audio_quirk[]) {
1326                         {
1327                                 .ifnum = 0,
1328                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1329                         },
1330                         {
1331                                 .ifnum = 1,
1332                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1333                         },
1334                         {
1335                                 .ifnum = -1
1336                         }
1337                 }
1338         }
1339 },
1340 {
1341         USB_DEVICE(0x0582, 0x009a),
1342         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1343                 .vendor_name = "EDIROL",
1344                 .product_name = "UM-3EX",
1345                 .ifnum = 0,
1346                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1347                 .data = & (const struct snd_usb_midi_endpoint_info) {
1348                         .out_cables = 0x000f,
1349                         .in_cables  = 0x000f
1350                 }
1351         }
1352 },
1353 {
1354         /*
1355          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1356          * is standard compliant, but has only 16-bit PCM and no MIDI.
1357          */
1358         USB_DEVICE(0x0582, 0x00a3),
1359         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1360                 .vendor_name = "EDIROL",
1361                 .product_name = "UA-4FX",
1362                 .ifnum = QUIRK_ANY_INTERFACE,
1363                 .type = QUIRK_COMPOSITE,
1364                 .data = (const struct snd_usb_audio_quirk[]) {
1365                         {
1366                                 .ifnum = 0,
1367                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1368                         },
1369                         {
1370                                 .ifnum = 1,
1371                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1372                         },
1373                         {
1374                                 .ifnum = 2,
1375                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1376                         },
1377                         {
1378                                 .ifnum = -1
1379                         }
1380                 }
1381         }
1382 },
1383         /* TODO: add Edirol MD-P1 support */
1384 {
1385         USB_DEVICE(0x582, 0x00a6),
1386         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1387                 .vendor_name = "Roland",
1388                 .product_name = "Juno-G",
1389                 .ifnum = 0,
1390                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1391                 .data = & (const struct snd_usb_midi_endpoint_info) {
1392                         .out_cables = 0x0001,
1393                         .in_cables  = 0x0001
1394                 }
1395         }
1396 },
1397 {
1398         /* Roland SH-201 */
1399         USB_DEVICE(0x0582, 0x00ad),
1400         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1401                 .vendor_name = "Roland",
1402                 .product_name = "SH-201",
1403                 .ifnum = QUIRK_ANY_INTERFACE,
1404                 .type = QUIRK_COMPOSITE,
1405                 .data = (const struct snd_usb_audio_quirk[]) {
1406                         {
1407                                 .ifnum = 0,
1408                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1409                         },
1410                         {
1411                                 .ifnum = 1,
1412                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1413                         },
1414                         {
1415                                 .ifnum = 2,
1416                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1417                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1418                                         .out_cables = 0x0001,
1419                                         .in_cables  = 0x0001
1420                                 }
1421                         },
1422                         {
1423                                 .ifnum = -1
1424                         }
1425                 }
1426         }
1427 },
1428 {
1429         /* Roland SonicCell */
1430         USB_DEVICE(0x0582, 0x00c2),
1431         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432                 .vendor_name = "Roland",
1433                 .product_name = "SonicCell",
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_STANDARD_INTERFACE
1440                         },
1441                         {
1442                                 .ifnum = 1,
1443                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1444                         },
1445                         {
1446                                 .ifnum = 2,
1447                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1448                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1449                                         .out_cables = 0x0001,
1450                                         .in_cables  = 0x0001
1451                                 }
1452                         },
1453                         {
1454                                 .ifnum = -1
1455                         }
1456                 }
1457         }
1458 },
1459 {
1460         /* Edirol M-16DX */
1461         /* FIXME: This quirk gives a good-working capture stream but the
1462          *        playback seems problematic because of lacking of sync
1463          *        with capture stream.  It needs to sync with the capture
1464          *        clock.  As now, you'll get frequent sound distortions
1465          *        via the playback.
1466          */
1467         USB_DEVICE(0x0582, 0x00c4),
1468         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1469                 .ifnum = QUIRK_ANY_INTERFACE,
1470                 .type = QUIRK_COMPOSITE,
1471                 .data = (const struct snd_usb_audio_quirk[]) {
1472                         {
1473                                 .ifnum = 0,
1474                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1475                         },
1476                         {
1477                                 .ifnum = 1,
1478                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1479                         },
1480                         {
1481                                 .ifnum = 2,
1482                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1483                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1484                                         .out_cables = 0x0001,
1485                                         .in_cables  = 0x0001
1486                                 }
1487                         },
1488                         {
1489                                 .ifnum = -1
1490                         }
1491                 }
1492         }
1493 },
1494 {
1495         /* BOSS GT-10 */
1496         USB_DEVICE(0x0582, 0x00da),
1497         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1498                 .ifnum = QUIRK_ANY_INTERFACE,
1499                 .type = QUIRK_COMPOSITE,
1500                 .data = (const struct snd_usb_audio_quirk[]) {
1501                         {
1502                                 .ifnum = 0,
1503                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1504                         },
1505                         {
1506                                 .ifnum = 1,
1507                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1508                         },
1509                         {
1510                                 .ifnum = 2,
1511                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1512                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1513                                         .out_cables = 0x0001,
1514                                         .in_cables  = 0x0001
1515                                 }
1516                         },
1517                         {
1518                                 .ifnum = -1
1519                         }
1520                 }
1521         }
1522 },
1523 {
1524         /* Advanced modes of the Edirol UA-25EX.
1525          * For the standard mode, UA-25EX has ID 0582:00e7, which
1526          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1527          */
1528         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1529         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1530                 .vendor_name = "EDIROL",
1531                 .product_name = "UA-25EX",
1532                 .ifnum = QUIRK_ANY_INTERFACE,
1533                 .type = QUIRK_COMPOSITE,
1534                 .data = (const struct snd_usb_audio_quirk[]) {
1535                         {
1536                                 .ifnum = 0,
1537                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1538                         },
1539                         {
1540                                 .ifnum = 1,
1541                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1542                         },
1543                         {
1544                                 .ifnum = 2,
1545                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1546                         },
1547                         {
1548                                 .ifnum = -1
1549                         }
1550                 }
1551         }
1552 },
1553 {
1554         /* has ID 0x00ea when not in Advanced Driver mode */
1555         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1556         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1557                 /* .vendor_name = "Roland", */
1558                 /* .product_name = "UA-1G", */
1559                 .ifnum = QUIRK_ANY_INTERFACE,
1560                 .type = QUIRK_COMPOSITE,
1561                 .data = (const struct snd_usb_audio_quirk[]) {
1562                         {
1563                                 .ifnum = 0,
1564                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1565                         },
1566                         {
1567                                 .ifnum = 1,
1568                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1569                         },
1570                         {
1571                                 .ifnum = -1
1572                         }
1573                 }
1574         }
1575 },
1576 {
1577         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1578         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1579                 /* .vendor_name = "Roland", */
1580                 /* .product_name = "UM-1G", */
1581                 .ifnum = 0,
1582                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1583                 .data = & (const struct snd_usb_midi_endpoint_info) {
1584                         .out_cables = 0x0001,
1585                         .in_cables  = 0x0001
1586                 }
1587         }
1588 },
1589 {
1590         /* Boss JS-8 Jam Station  */
1591         USB_DEVICE(0x0582, 0x0109),
1592         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1593                 /* .vendor_name = "BOSS", */
1594                 /* .product_name = "JS-8", */
1595                 .ifnum = QUIRK_ANY_INTERFACE,
1596                 .type = QUIRK_COMPOSITE,
1597                 .data = (const struct snd_usb_audio_quirk[]) {
1598                         {
1599                                 .ifnum = 0,
1600                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1601                         },
1602                         {
1603                                 .ifnum = 1,
1604                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1605                         },
1606                         {
1607                                 .ifnum = 2,
1608                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1609                         },
1610                         {
1611                                 .ifnum = -1
1612                         }
1613                 }
1614         }
1615 },
1616 {
1617         /* has ID 0x0110 when not in Advanced Driver mode */
1618         USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1619         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1620                 /* .vendor_name = "Roland", */
1621                 /* .product_name = "A-PRO", */
1622                 .ifnum = 0,
1623                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1624                 .data = & (const struct snd_usb_midi_endpoint_info) {
1625                         .out_cables = 0x0003,
1626                         .in_cables  = 0x0007
1627                 }
1628         }
1629 },
1630 {
1631         USB_DEVICE(0x0582, 0x0113),
1632         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1633                 /* .vendor_name = "BOSS", */
1634                 /* .product_name = "ME-25", */
1635                 .ifnum = QUIRK_ANY_INTERFACE,
1636                 .type = QUIRK_COMPOSITE,
1637                 .data = (const struct snd_usb_audio_quirk[]) {
1638                         {
1639                                 .ifnum = 0,
1640                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1641                         },
1642                         {
1643                                 .ifnum = 1,
1644                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1645                         },
1646                         {
1647                                 .ifnum = 2,
1648                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1649                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1650                                         .out_cables = 0x0001,
1651                                         .in_cables  = 0x0001
1652                                 }
1653                         },
1654                         {
1655                                 .ifnum = -1
1656                         }
1657                 }
1658         }
1659 },
1660 {
1661         USB_DEVICE(0x0582, 0x0127),
1662         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1663                 /* .vendor_name = "Roland", */
1664                 /* .product_name = "GR-55", */
1665                 .ifnum = QUIRK_ANY_INTERFACE,
1666                 .type = QUIRK_COMPOSITE,
1667                 .data = (const struct snd_usb_audio_quirk[]) {
1668                         {
1669                                 .ifnum = 0,
1670                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1671                         },
1672                         {
1673                                 .ifnum = 1,
1674                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1675                         },
1676                         {
1677                                 .ifnum = 2,
1678                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1679                         },
1680                         {
1681                                 .ifnum = -1
1682                         }
1683                 }
1684         }
1685 },
1686
1687 /* Guillemot devices */
1688 {
1689         /*
1690          * This is for the "Windows Edition" where the external MIDI ports are
1691          * the only MIDI ports; the control data is reported through HID
1692          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1693          * compliant USB MIDI ports for external MIDI and controls.
1694          */
1695         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1696         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1697                 .vendor_name = "Hercules",
1698                 .product_name = "DJ Console (WE)",
1699                 .ifnum = 4,
1700                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1701                 .data = & (const struct snd_usb_midi_endpoint_info) {
1702                         .out_cables = 0x0001,
1703                         .in_cables = 0x0001
1704                 }
1705         }
1706 },
1707
1708 /* Midiman/M-Audio devices */
1709 {
1710         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1711         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1712                 .vendor_name = "M-Audio",
1713                 .product_name = "MidiSport 2x2",
1714                 .ifnum = QUIRK_ANY_INTERFACE,
1715                 .type = QUIRK_MIDI_MIDIMAN,
1716                 .data = & (const struct snd_usb_midi_endpoint_info) {
1717                         .out_cables = 0x0003,
1718                         .in_cables  = 0x0003
1719                 }
1720         }
1721 },
1722 {
1723         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1724         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1725                 .vendor_name = "M-Audio",
1726                 .product_name = "MidiSport 1x1",
1727                 .ifnum = QUIRK_ANY_INTERFACE,
1728                 .type = QUIRK_MIDI_MIDIMAN,
1729                 .data = & (const struct snd_usb_midi_endpoint_info) {
1730                         .out_cables = 0x0001,
1731                         .in_cables  = 0x0001
1732                 }
1733         }
1734 },
1735 {
1736         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1737         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1738                 .vendor_name = "M-Audio",
1739                 .product_name = "Keystation",
1740                 .ifnum = QUIRK_ANY_INTERFACE,
1741                 .type = QUIRK_MIDI_MIDIMAN,
1742                 .data = & (const struct snd_usb_midi_endpoint_info) {
1743                         .out_cables = 0x0001,
1744                         .in_cables  = 0x0001
1745                 }
1746         }
1747 },
1748 {
1749         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1750         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1751                 .vendor_name = "M-Audio",
1752                 .product_name = "MidiSport 4x4",
1753                 .ifnum = QUIRK_ANY_INTERFACE,
1754                 .type = QUIRK_MIDI_MIDIMAN,
1755                 .data = & (const struct snd_usb_midi_endpoint_info) {
1756                         .out_cables = 0x000f,
1757                         .in_cables  = 0x000f
1758                 }
1759         }
1760 },
1761 {
1762         /*
1763          * For hardware revision 1.05; in the later revisions (1.10 and
1764          * 1.21), 0x1031 is the ID for the device without firmware.
1765          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1766          */
1767         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1768         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1769                 .vendor_name = "M-Audio",
1770                 .product_name = "MidiSport 8x8",
1771                 .ifnum = QUIRK_ANY_INTERFACE,
1772                 .type = QUIRK_MIDI_MIDIMAN,
1773                 .data = & (const struct snd_usb_midi_endpoint_info) {
1774                         .out_cables = 0x01ff,
1775                         .in_cables  = 0x01ff
1776                 }
1777         }
1778 },
1779 {
1780         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1781         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1782                 .vendor_name = "M-Audio",
1783                 .product_name = "MidiSport 8x8",
1784                 .ifnum = QUIRK_ANY_INTERFACE,
1785                 .type = QUIRK_MIDI_MIDIMAN,
1786                 .data = & (const struct snd_usb_midi_endpoint_info) {
1787                         .out_cables = 0x01ff,
1788                         .in_cables  = 0x01ff
1789                 }
1790         }
1791 },
1792 {
1793         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1794         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1795                 .vendor_name = "M-Audio",
1796                 .product_name = "MidiSport 2x4",
1797                 .ifnum = QUIRK_ANY_INTERFACE,
1798                 .type = QUIRK_MIDI_MIDIMAN,
1799                 .data = & (const struct snd_usb_midi_endpoint_info) {
1800                         .out_cables = 0x000f,
1801                         .in_cables  = 0x0003
1802                 }
1803         }
1804 },
1805 {
1806         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1807         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1808                 .vendor_name = "M-Audio",
1809                 .product_name = "Quattro",
1810                 .ifnum = QUIRK_ANY_INTERFACE,
1811                 .type = QUIRK_COMPOSITE,
1812                 .data = & (const struct snd_usb_audio_quirk[]) {
1813                         /*
1814                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1815                          * and share endpoints with the other interfaces.
1816                          * Ignore them.  The other interfaces can do 24 bits,
1817                          * but captured samples are big-endian (see usbaudio.c).
1818                          */
1819                         {
1820                                 .ifnum = 0,
1821                                 .type = QUIRK_IGNORE_INTERFACE
1822                         },
1823                         {
1824                                 .ifnum = 1,
1825                                 .type = QUIRK_IGNORE_INTERFACE
1826                         },
1827                         {
1828                                 .ifnum = 2,
1829                                 .type = QUIRK_IGNORE_INTERFACE
1830                         },
1831                         {
1832                                 .ifnum = 3,
1833                                 .type = QUIRK_IGNORE_INTERFACE
1834                         },
1835                         {
1836                                 .ifnum = 4,
1837                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1838                         },
1839                         {
1840                                 .ifnum = 5,
1841                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1842                         },
1843                         {
1844                                 .ifnum = 6,
1845                                 .type = QUIRK_IGNORE_INTERFACE
1846                         },
1847                         {
1848                                 .ifnum = 7,
1849                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1850                         },
1851                         {
1852                                 .ifnum = 8,
1853                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1854                         },
1855                         {
1856                                 .ifnum = 9,
1857                                 .type = QUIRK_MIDI_MIDIMAN,
1858                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1859                                         .out_cables = 0x0001,
1860                                         .in_cables  = 0x0001
1861                                 }
1862                         },
1863                         {
1864                                 .ifnum = -1
1865                         }
1866                 }
1867         }
1868 },
1869 {
1870         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1871         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1872                 .vendor_name = "M-Audio",
1873                 .product_name = "AudioPhile",
1874                 .ifnum = 6,
1875                 .type = QUIRK_MIDI_MIDIMAN,
1876                 .data = & (const struct snd_usb_midi_endpoint_info) {
1877                         .out_cables = 0x0001,
1878                         .in_cables  = 0x0001
1879                 }
1880         }
1881 },
1882 {
1883         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1884         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1885                 .vendor_name = "M-Audio",
1886                 .product_name = "Ozone",
1887                 .ifnum = 3,
1888                 .type = QUIRK_MIDI_MIDIMAN,
1889                 .data = & (const struct snd_usb_midi_endpoint_info) {
1890                         .out_cables = 0x0001,
1891                         .in_cables  = 0x0001
1892                 }
1893         }
1894 },
1895 {
1896         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1897         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1898                 .vendor_name = "M-Audio",
1899                 .product_name = "OmniStudio",
1900                 .ifnum = QUIRK_ANY_INTERFACE,
1901                 .type = QUIRK_COMPOSITE,
1902                 .data = & (const struct snd_usb_audio_quirk[]) {
1903                         {
1904                                 .ifnum = 0,
1905                                 .type = QUIRK_IGNORE_INTERFACE
1906                         },
1907                         {
1908                                 .ifnum = 1,
1909                                 .type = QUIRK_IGNORE_INTERFACE
1910                         },
1911                         {
1912                                 .ifnum = 2,
1913                                 .type = QUIRK_IGNORE_INTERFACE
1914                         },
1915                         {
1916                                 .ifnum = 3,
1917                                 .type = QUIRK_IGNORE_INTERFACE
1918                         },
1919                         {
1920                                 .ifnum = 4,
1921                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1922                         },
1923                         {
1924                                 .ifnum = 5,
1925                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1926                         },
1927                         {
1928                                 .ifnum = 6,
1929                                 .type = QUIRK_IGNORE_INTERFACE
1930                         },
1931                         {
1932                                 .ifnum = 7,
1933                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1934                         },
1935                         {
1936                                 .ifnum = 8,
1937                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1938                         },
1939                         {
1940                                 .ifnum = 9,
1941                                 .type = QUIRK_MIDI_MIDIMAN,
1942                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1943                                         .out_cables = 0x0001,
1944                                         .in_cables  = 0x0001
1945                                 }
1946                         },
1947                         {
1948                                 .ifnum = -1
1949                         }
1950                 }
1951         }
1952 },
1953 {
1954         USB_DEVICE(0x0763, 0x2019),
1955         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1956                 /* .vendor_name = "M-Audio", */
1957                 /* .product_name = "Ozone Academic", */
1958                 .ifnum = QUIRK_ANY_INTERFACE,
1959                 .type = QUIRK_COMPOSITE,
1960                 .data = & (const struct snd_usb_audio_quirk[]) {
1961                         {
1962                                 .ifnum = 0,
1963                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1964                         },
1965                         {
1966                                 .ifnum = 1,
1967                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1968                         },
1969                         {
1970                                 .ifnum = 2,
1971                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1972                         },
1973                         {
1974                                 .ifnum = 3,
1975                                 .type = QUIRK_MIDI_MIDIMAN,
1976                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1977                                         .out_cables = 0x0001,
1978                                         .in_cables  = 0x0001
1979                                 }
1980                         },
1981                         {
1982                                 .ifnum = -1
1983                         }
1984                 }
1985         }
1986 },
1987 {
1988         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
1989         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1990                 /* .vendor_name = "M-Audio", */
1991                 /* .product_name = "Fast Track Ultra", */
1992                 .ifnum = QUIRK_ANY_INTERFACE,
1993                 .type = QUIRK_COMPOSITE,
1994                 .data = & (const struct snd_usb_audio_quirk[]) {
1995                         {
1996                                 .ifnum = 0,
1997                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
1998                         },
1999                         {
2000                                 .ifnum = 1,
2001                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2002                                 .data = & (const struct audioformat) {
2003                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2004                                         .channels = 8,
2005                                         .iface = 1,
2006                                         .altsetting = 1,
2007                                         .altset_idx = 1,
2008                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2009                                         .endpoint = 0x01,
2010                                         .ep_attr = 0x09,
2011                                         .rates = SNDRV_PCM_RATE_44100 |
2012                                                  SNDRV_PCM_RATE_48000 |
2013                                                  SNDRV_PCM_RATE_88200 |
2014                                                  SNDRV_PCM_RATE_96000,
2015                                         .rate_min = 44100,
2016                                         .rate_max = 96000,
2017                                         .nr_rates = 4,
2018                                         .rate_table = (unsigned int[]) {
2019                                                 44100, 48000, 88200, 96000
2020                                         }
2021                                 }
2022                         },
2023                         {
2024                                 .ifnum = 2,
2025                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2026                                 .data = & (const struct audioformat) {
2027                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2028                                         .channels = 8,
2029                                         .iface = 2,
2030                                         .altsetting = 1,
2031                                         .altset_idx = 1,
2032                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2033                                         .endpoint = 0x81,
2034                                         .ep_attr = 0x05,
2035                                         .rates = SNDRV_PCM_RATE_44100 |
2036                                                  SNDRV_PCM_RATE_48000 |
2037                                                  SNDRV_PCM_RATE_88200 |
2038                                                  SNDRV_PCM_RATE_96000,
2039                                         .rate_min = 44100,
2040                                         .rate_max = 96000,
2041                                         .nr_rates = 4,
2042                                         .rate_table = (unsigned int[]) {
2043                                                 44100, 48000, 88200, 96000
2044                                         }
2045                                 }
2046                         },
2047                         /* interface 3 (MIDI) is standard compliant */
2048                         {
2049                                 .ifnum = -1
2050                         }
2051                 }
2052         }
2053 },
2054 {
2055         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2056         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2057                 /* .vendor_name = "M-Audio", */
2058                 /* .product_name = "Fast Track Ultra 8R", */
2059                 .ifnum = QUIRK_ANY_INTERFACE,
2060                 .type = QUIRK_COMPOSITE,
2061                 .data = & (const struct snd_usb_audio_quirk[]) {
2062                         {
2063                                 .ifnum = 0,
2064                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2065                         },
2066                         {
2067                                 .ifnum = 1,
2068                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2069                                 .data = & (const struct audioformat) {
2070                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2071                                         .channels = 8,
2072                                         .iface = 1,
2073                                         .altsetting = 1,
2074                                         .altset_idx = 1,
2075                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2076                                         .endpoint = 0x01,
2077                                         .ep_attr = 0x09,
2078                                         .rates = SNDRV_PCM_RATE_44100 |
2079                                                  SNDRV_PCM_RATE_48000 |
2080                                                  SNDRV_PCM_RATE_88200 |
2081                                                  SNDRV_PCM_RATE_96000,
2082                                         .rate_min = 44100,
2083                                         .rate_max = 96000,
2084                                         .nr_rates = 4,
2085                                         .rate_table = (unsigned int[]) {
2086                                                         44100, 48000, 88200, 96000
2087                                         }
2088                                 }
2089                         },
2090                         {
2091                                 .ifnum = 2,
2092                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2093                                 .data = & (const struct audioformat) {
2094                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2095                                         .channels = 8,
2096                                         .iface = 2,
2097                                         .altsetting = 1,
2098                                         .altset_idx = 1,
2099                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2100                                         .endpoint = 0x81,
2101                                         .ep_attr = 0x05,
2102                                         .rates = SNDRV_PCM_RATE_44100 |
2103                                                  SNDRV_PCM_RATE_48000 |
2104                                                  SNDRV_PCM_RATE_88200 |
2105                                                  SNDRV_PCM_RATE_96000,
2106                                         .rate_min = 44100,
2107                                         .rate_max = 96000,
2108                                         .nr_rates = 4,
2109                                         .rate_table = (unsigned int[]) {
2110                                                 44100, 48000, 88200, 96000
2111                                         }
2112                                 }
2113                         },
2114                         /* interface 3 (MIDI) is standard compliant */
2115                         {
2116                                 .ifnum = -1
2117                         }
2118                 }
2119         }
2120 },
2121
2122 /* Casio devices */
2123 {
2124         USB_DEVICE(0x07cf, 0x6801),
2125         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2126                 .vendor_name = "Casio",
2127                 .product_name = "PL-40R",
2128                 .ifnum = 0,
2129                 .type = QUIRK_MIDI_YAMAHA
2130         }
2131 },
2132 {
2133         /* this ID is used by several devices without a product ID */
2134         USB_DEVICE(0x07cf, 0x6802),
2135         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2136                 .vendor_name = "Casio",
2137                 .product_name = "Keyboard",
2138                 .ifnum = 0,
2139                 .type = QUIRK_MIDI_YAMAHA
2140         }
2141 },
2142
2143 /* Mark of the Unicorn devices */
2144 {
2145         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2146         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2147                        USB_DEVICE_ID_MATCH_PRODUCT |
2148                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2149         .idVendor = 0x07fd,
2150         .idProduct = 0x0001,
2151         .bDeviceSubClass = 2,
2152         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2153                 .vendor_name = "MOTU",
2154                 .product_name = "Fastlane",
2155                 .ifnum = QUIRK_ANY_INTERFACE,
2156                 .type = QUIRK_COMPOSITE,
2157                 .data = & (const struct snd_usb_audio_quirk[]) {
2158                         {
2159                                 .ifnum = 0,
2160                                 .type = QUIRK_MIDI_RAW_BYTES
2161                         },
2162                         {
2163                                 .ifnum = 1,
2164                                 .type = QUIRK_IGNORE_INTERFACE
2165                         },
2166                         {
2167                                 .ifnum = -1
2168                         }
2169                 }
2170         }
2171 },
2172
2173 /* Emagic devices */
2174 {
2175         USB_DEVICE(0x086a, 0x0001),
2176         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2177                 .vendor_name = "Emagic",
2178                 /* .product_name = "Unitor8", */
2179                 .ifnum = 2,
2180                 .type = QUIRK_MIDI_EMAGIC,
2181                 .data = & (const struct snd_usb_midi_endpoint_info) {
2182                         .out_cables = 0x80ff,
2183                         .in_cables  = 0x80ff
2184                 }
2185         }
2186 },
2187 {
2188         USB_DEVICE(0x086a, 0x0002),
2189         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2190                 .vendor_name = "Emagic",
2191                 /* .product_name = "AMT8", */
2192                 .ifnum = 2,
2193                 .type = QUIRK_MIDI_EMAGIC,
2194                 .data = & (const struct snd_usb_midi_endpoint_info) {
2195                         .out_cables = 0x80ff,
2196                         .in_cables  = 0x80ff
2197                 }
2198         }
2199 },
2200 {
2201         USB_DEVICE(0x086a, 0x0003),
2202         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2203                 .vendor_name = "Emagic",
2204                 /* .product_name = "MT4", */
2205                 .ifnum = 2,
2206                 .type = QUIRK_MIDI_EMAGIC,
2207                 .data = & (const struct snd_usb_midi_endpoint_info) {
2208                         .out_cables = 0x800f,
2209                         .in_cables  = 0x8003
2210                 }
2211         }
2212 },
2213
2214 /* KORG devices */
2215 {
2216         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2217         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2218                 .vendor_name = "KORG, Inc.",
2219                 /* .product_name = "PANDORA PX5D", */
2220                 .ifnum = 3,
2221                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2222         }
2223 },
2224
2225 /* AKAI devices */
2226 {
2227         USB_DEVICE(0x09e8, 0x0062),
2228         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2229                 .vendor_name = "AKAI",
2230                 .product_name = "MPD16",
2231                 .ifnum = 0,
2232                 .type = QUIRK_MIDI_AKAI,
2233         }
2234 },
2235
2236 /* TerraTec devices */
2237 {
2238         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2239         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2240                 .vendor_name = "TerraTec",
2241                 .product_name = "PHASE 26",
2242                 .ifnum = 3,
2243                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2244         }
2245 },
2246 {
2247         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2248         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2249                 .vendor_name = "TerraTec",
2250                 .product_name = "PHASE 26",
2251                 .ifnum = 3,
2252                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2253         }
2254 },
2255 {
2256         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2257         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2258                 .vendor_name = "TerraTec",
2259                 .product_name = "PHASE 26",
2260                 .ifnum = 3,
2261                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2262         }
2263 },
2264 {
2265         USB_DEVICE(0x0ccd, 0x0028),
2266         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2267                 .vendor_name = "TerraTec",
2268                 .product_name = "Aureon5.1MkII",
2269                 .ifnum = QUIRK_NO_INTERFACE
2270         }
2271 },
2272 {
2273         USB_DEVICE(0x0ccd, 0x0035),
2274         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2275                 .vendor_name = "Miditech",
2276                 .product_name = "Play'n Roll",
2277                 .ifnum = 0,
2278                 .type = QUIRK_MIDI_CME
2279         }
2280 },
2281
2282 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2283 {
2284         USB_DEVICE(0x103d, 0x0100),
2285                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2286                 .vendor_name = "Stanton",
2287                 .product_name = "ScratchAmp",
2288                 .ifnum = QUIRK_NO_INTERFACE
2289         }
2290 },
2291 {
2292         USB_DEVICE(0x103d, 0x0101),
2293                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2294                 .vendor_name = "Stanton",
2295                 .product_name = "ScratchAmp",
2296                 .ifnum = QUIRK_NO_INTERFACE
2297         }
2298 },
2299
2300 /* Novation EMS devices */
2301 {
2302         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2303         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2304                 .vendor_name = "Novation",
2305                 .product_name = "ReMOTE Audio/XStation",
2306                 .ifnum = 4,
2307                 .type = QUIRK_MIDI_NOVATION
2308         }
2309 },
2310 {
2311         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2312         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2313                 .vendor_name = "Novation",
2314                 .product_name = "Speedio",
2315                 .ifnum = 3,
2316                 .type = QUIRK_MIDI_NOVATION
2317         }
2318 },
2319 {
2320         USB_DEVICE(0x1235, 0x000e),
2321         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2322                 /* .vendor_name = "Novation", */
2323                 /* .product_name = "Launchpad", */
2324                 .ifnum = 0,
2325                 .type = QUIRK_MIDI_RAW_BYTES
2326         }
2327 },
2328 {
2329         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2330         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2331                 .vendor_name = "Novation",
2332                 .product_name = "ReMOTE25",
2333                 .ifnum = 0,
2334                 .type = QUIRK_MIDI_NOVATION
2335         }
2336 },
2337
2338 /* Access Music devices */
2339 {
2340         /* VirusTI Desktop */
2341         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2342         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2343                 .ifnum = QUIRK_ANY_INTERFACE,
2344                 .type = QUIRK_COMPOSITE,
2345                 .data = &(const struct snd_usb_audio_quirk[]) {
2346                         {
2347                                 .ifnum = 3,
2348                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2349                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2350                                         .out_cables = 0x0003,
2351                                         .in_cables  = 0x0003
2352                                 }
2353                         },
2354                         {
2355                                 .ifnum = 4,
2356                                 .type = QUIRK_IGNORE_INTERFACE
2357                         },
2358                         {
2359                                 .ifnum = -1
2360                         }
2361                 }
2362         }
2363 },
2364
2365 /* */
2366 {
2367         /* aka. Serato Scratch Live DJ Box */
2368         USB_DEVICE(0x13e5, 0x0001),
2369         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2370                 .vendor_name = "Rane",
2371                 .product_name = "SL-1",
2372                 .ifnum = QUIRK_NO_INTERFACE
2373         }
2374 },
2375
2376 /* Native Instruments MK2 series */
2377 {
2378         /* Komplete Audio 6 */
2379         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2380         .idVendor = 0x17cc,
2381         .idProduct = 0x1000,
2382 },
2383 {
2384         /* Traktor Audio 6 */
2385         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2386         .idVendor = 0x17cc,
2387         .idProduct = 0x1010,
2388 },
2389 {
2390         /* Traktor Audio 10 */
2391         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2392         .idVendor = 0x17cc,
2393         .idProduct = 0x1020,
2394 },
2395
2396 /* Miditech devices */
2397 {
2398         USB_DEVICE(0x4752, 0x0011),
2399         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2400                 .vendor_name = "Miditech",
2401                 .product_name = "Midistart-2",
2402                 .ifnum = 0,
2403                 .type = QUIRK_MIDI_CME
2404         }
2405 },
2406
2407 /* Central Music devices */
2408 {
2409         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2410         USB_DEVICE(0x7104, 0x2202),
2411         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2412                 .ifnum = 0,
2413                 .type = QUIRK_MIDI_CME
2414         }
2415 },
2416
2417 /* Hauppauge HVR-950Q and HVR-850 */
2418 {
2419         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2420         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2421                        USB_DEVICE_ID_MATCH_INT_CLASS |
2422                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2423         .bInterfaceClass = USB_CLASS_AUDIO,
2424         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2425         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2426                 .vendor_name = "Hauppauge",
2427                 .product_name = "HVR-950Q",
2428                 .ifnum = QUIRK_ANY_INTERFACE,
2429                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2430         }
2431 },
2432 {
2433         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2434         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2435                        USB_DEVICE_ID_MATCH_INT_CLASS |
2436                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2437         .bInterfaceClass = USB_CLASS_AUDIO,
2438         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2439         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2440                 .vendor_name = "Hauppauge",
2441                 .product_name = "HVR-850",
2442                 .ifnum = QUIRK_ANY_INTERFACE,
2443                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2444         }
2445 },
2446 {
2447         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2448         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2449                        USB_DEVICE_ID_MATCH_INT_CLASS |
2450                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2451         .bInterfaceClass = USB_CLASS_AUDIO,
2452         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2453         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2454                 .vendor_name = "Hauppauge",
2455                 .product_name = "HVR-950Q",
2456                 .ifnum = QUIRK_ANY_INTERFACE,
2457                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2458         }
2459 },
2460 {
2461         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2462         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2463                        USB_DEVICE_ID_MATCH_INT_CLASS |
2464                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2465         .bInterfaceClass = USB_CLASS_AUDIO,
2466         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2467         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2468                 .vendor_name = "Hauppauge",
2469                 .product_name = "HVR-950Q",
2470                 .ifnum = QUIRK_ANY_INTERFACE,
2471                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2472         }
2473 },
2474 {
2475         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2476         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2477                        USB_DEVICE_ID_MATCH_INT_CLASS |
2478                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2479         .bInterfaceClass = USB_CLASS_AUDIO,
2480         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2481         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2482                 .vendor_name = "Hauppauge",
2483                 .product_name = "HVR-950Q",
2484                 .ifnum = QUIRK_ANY_INTERFACE,
2485                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2486         }
2487 },
2488 {
2489         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2490         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2491                        USB_DEVICE_ID_MATCH_INT_CLASS |
2492                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2493         .bInterfaceClass = USB_CLASS_AUDIO,
2494         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2495         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2496                 .vendor_name = "Hauppauge",
2497                 .product_name = "HVR-950Q",
2498                 .ifnum = QUIRK_ANY_INTERFACE,
2499                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2500         }
2501 },
2502 {
2503         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2504         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2505                        USB_DEVICE_ID_MATCH_INT_CLASS |
2506                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2507         .bInterfaceClass = USB_CLASS_AUDIO,
2508         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2509         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2510                 .vendor_name = "Hauppauge",
2511                 .product_name = "HVR-950Q",
2512                 .ifnum = QUIRK_ANY_INTERFACE,
2513                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2514         }
2515 },
2516 {
2517         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2518         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2519                        USB_DEVICE_ID_MATCH_INT_CLASS |
2520                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2521         .bInterfaceClass = USB_CLASS_AUDIO,
2522         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2523         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2524                 .vendor_name = "Hauppauge",
2525                 .product_name = "HVR-950Q",
2526                 .ifnum = QUIRK_ANY_INTERFACE,
2527                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2528         }
2529 },
2530 {
2531         USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2532         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2533                        USB_DEVICE_ID_MATCH_INT_CLASS |
2534                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2535         .bInterfaceClass = USB_CLASS_AUDIO,
2536         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2537         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2538                 .vendor_name = "Hauppauge",
2539                 .product_name = "HVR-950Q",
2540                 .ifnum = QUIRK_ANY_INTERFACE,
2541                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2542         }
2543 },
2544
2545 /* Digidesign Mbox */
2546 {
2547         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2548         USB_DEVICE(0x0dba, 0x1000),
2549         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2550                 .vendor_name = "Digidesign",
2551                 .product_name = "MBox",
2552                 .ifnum = QUIRK_ANY_INTERFACE,
2553                 .type = QUIRK_COMPOSITE,
2554                 .data = (const struct snd_usb_audio_quirk[]){
2555                         {
2556                                 .ifnum = 0,
2557                                 .type = QUIRK_IGNORE_INTERFACE,
2558                         },
2559                         {
2560                                 .ifnum = 1,
2561                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2562                                 .data = &(const struct audioformat) {
2563                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2564                                         .channels = 2,
2565                                         .iface = 1,
2566                                         .altsetting = 1,
2567                                         .altset_idx = 1,
2568                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2569                                         .endpoint = 0x02,
2570                                         .ep_attr = 0x01,
2571                                         .maxpacksize = 0x130,
2572                                         .rates = SNDRV_PCM_RATE_44100 |
2573                                                  SNDRV_PCM_RATE_48000,
2574                                         .rate_min = 44100,
2575                                         .rate_max = 48000,
2576                                         .nr_rates = 2,
2577                                         .rate_table = (unsigned int[]) {
2578                                                 44100, 48000
2579                                         }
2580                                 }
2581                         },
2582                         {
2583                                 .ifnum = -1
2584                         }
2585                 }
2586
2587         }
2588 },
2589
2590 /* Microsoft XboxLive Headset/Xbox Communicator */
2591 {
2592         USB_DEVICE(0x045e, 0x0283),
2593         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2594         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2595                 .vendor_name = "Microsoft",
2596                 .product_name = "XboxLive Headset/Xbox Communicator",
2597                 .ifnum = QUIRK_ANY_INTERFACE,
2598                 .type = QUIRK_COMPOSITE,
2599                 .data = &(const struct snd_usb_audio_quirk[]) {
2600                         {
2601                                 /* playback */
2602                                 .ifnum = 0,
2603                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2604                                 .data = &(const struct audioformat) {
2605                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
2606                                         .channels = 1,
2607                                         .iface = 0,
2608                                         .altsetting = 0,
2609                                         .altset_idx = 0,
2610                                         .attributes = 0,
2611                                         .endpoint = 0x04,
2612                                         .ep_attr = 0x05,
2613                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
2614                                         .rate_min = 22050,
2615                                         .rate_max = 22050
2616                                 }
2617                         },
2618                         {
2619                                 /* capture */
2620                                 .ifnum = 1,
2621                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2622                                 .data = &(const struct audioformat) {
2623                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
2624                                         .channels = 1,
2625                                         .iface = 1,
2626                                         .altsetting = 0,
2627                                         .altset_idx = 0,
2628                                         .attributes = 0,
2629                                         .endpoint = 0x85,
2630                                         .ep_attr = 0x05,
2631                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
2632                                         .rate_min = 16000,
2633                                         .rate_max = 16000
2634                                 }
2635                         },
2636                         {
2637                                 .ifnum = -1
2638                         }
2639                 }
2640         }
2641 },
2642
2643 {
2644         /*
2645          * Some USB MIDI devices don't have an audio control interface,
2646          * so we have to grab MIDI streaming interfaces here.
2647          */
2648         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2649                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2650         .bInterfaceClass = USB_CLASS_AUDIO,
2651         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2652         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2653                 .ifnum = QUIRK_ANY_INTERFACE,
2654                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2655         }
2656 },
2657
2658 #undef USB_DEVICE_VENDOR_SPEC