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