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