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