sound/usb/usbquirks.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 /*
  43  * Yamaha devices
  44  */
  45
  46 #define YAMAHA_DEVICE(id, name) { \
  47         USB_DEVICE(0x0499, id), \
  48         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \
  49                 .vendor_name = "Yamaha", \
  50                 .product_name = name, \
  51                 .ifnum = QUIRK_ANY_INTERFACE, \
  52                 .type = QUIRK_MIDI_YAMAHA \
  53         } \
  54 }
  55 #define YAMAHA_INTERFACE(id, intf, name) { \
  56         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
  57         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \
  58                 .vendor_name = "Yamaha", \
  59                 .product_name = name, \
  60                 .ifnum = intf, \
  61                 .type = QUIRK_MIDI_YAMAHA \
  62         } \
  63 }
  64 YAMAHA_DEVICE(0x1000, "UX256"),
  65 YAMAHA_DEVICE(0x1001, "MU1000"),
  66 YAMAHA_DEVICE(0x1002, "MU2000"),
  67 YAMAHA_DEVICE(0x1003, "MU500"),
  68 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
  69 YAMAHA_DEVICE(0x1005, "MOTIF6"),
  70 YAMAHA_DEVICE(0x1006, "MOTIF7"),
  71 YAMAHA_DEVICE(0x1007, "MOTIF8"),
  72 YAMAHA_DEVICE(0x1008, "UX96"),
  73 YAMAHA_DEVICE(0x1009, "UX16"),
  74 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
  75 YAMAHA_DEVICE(0x100c, "UC-MX"),
  76 YAMAHA_DEVICE(0x100d, "UC-KX"),
  77 YAMAHA_DEVICE(0x100e, "S08"),
  78 YAMAHA_DEVICE(0x100f, "CLP-150"),
  79 YAMAHA_DEVICE(0x1010, "CLP-170"),
  80 YAMAHA_DEVICE(0x1011, "P-250"),
  81 YAMAHA_DEVICE(0x1012, "TYROS"),
  82 YAMAHA_DEVICE(0x1013, "PF-500"),
  83 YAMAHA_DEVICE(0x1014, "S90"),
  84 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
  85 YAMAHA_DEVICE(0x1017, "CVP-204"),
  86 YAMAHA_DEVICE(0x1018, "CVP-206"),
  87 YAMAHA_DEVICE(0x1019, "CVP-208"),
  88 YAMAHA_DEVICE(0x101a, "CVP-210"),
  89 YAMAHA_DEVICE(0x101b, "PSR-1100"),
  90 YAMAHA_DEVICE(0x101c, "PSR-2100"),
  91 YAMAHA_DEVICE(0x101d, "CLP-175"),
  92 YAMAHA_DEVICE(0x101e, "PSR-K1"),
  93 YAMAHA_DEVICE(0x1020, "EZ-250i"),
  94 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
  95 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
  96 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
  97 YAMAHA_DEVICE(0x1024, "CVP-301"),
  98 YAMAHA_DEVICE(0x1025, "CVP-303"),
  99 YAMAHA_DEVICE(0x1026, "CVP-305"),
 100 YAMAHA_DEVICE(0x1027, "CVP-307"),
 101 YAMAHA_DEVICE(0x1028, "CVP-309"),
 102 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 103 YAMAHA_DEVICE(0x102a, "PSR-1500"),
 104 YAMAHA_DEVICE(0x102b, "PSR-3000"),
 105 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 106 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 107 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 108 YAMAHA_DEVICE(0x1032, "DGX-305"),
 109 YAMAHA_DEVICE(0x1033, "DGX-505"),
 110 YAMAHA_DEVICE(0x1034, NULL),
 111 YAMAHA_DEVICE(0x1035, NULL),
 112 YAMAHA_DEVICE(0x1036, NULL),
 113 YAMAHA_DEVICE(0x1037, NULL),
 114 YAMAHA_DEVICE(0x1038, NULL),
 115 YAMAHA_DEVICE(0x1039, NULL),
 116 YAMAHA_DEVICE(0x103a, NULL),
 117 YAMAHA_DEVICE(0x103b, NULL),
 118 YAMAHA_DEVICE(0x103c, NULL),
 119 YAMAHA_DEVICE(0x103d, NULL),
 120 YAMAHA_DEVICE(0x103e, NULL),
 121 YAMAHA_DEVICE(0x103f, NULL),
 122 YAMAHA_DEVICE(0x1040, NULL),
 123 YAMAHA_DEVICE(0x1041, NULL),
 124 YAMAHA_DEVICE(0x2000, "DGP-7"),
 125 YAMAHA_DEVICE(0x2001, "DGP-5"),
 126 YAMAHA_DEVICE(0x2002, NULL),
 127 YAMAHA_DEVICE(0x5000, "CS1D"),
 128 YAMAHA_DEVICE(0x5001, "DSP1D"),
 129 YAMAHA_DEVICE(0x5002, "DME32"),
 130 YAMAHA_DEVICE(0x5003, "DM2000"),
 131 YAMAHA_DEVICE(0x5004, "02R96"),
 132 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 133 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 134 YAMAHA_DEVICE(0x5007, "DM1000"),
 135 YAMAHA_DEVICE(0x5008, "01V96"),
 136 YAMAHA_DEVICE(0x5009, "SPX2000"),
 137 YAMAHA_DEVICE(0x500a, "PM5D"),
 138 YAMAHA_DEVICE(0x500b, "DME64N"),
 139 YAMAHA_DEVICE(0x500c, "DME24N"),
 140 YAMAHA_DEVICE(0x500d, NULL),
 141 YAMAHA_DEVICE(0x500e, NULL),
 142 YAMAHA_DEVICE(0x7000, "DTX"),
 143 YAMAHA_DEVICE(0x7010, "UB99"),
 144 #undef YAMAHA_DEVICE
 145 #undef YAMAHA_INTERFACE
 146
 147 /*
 148  * Roland/RolandED/Edirol/BOSS devices
 149  */
 150 {
 151         USB_DEVICE(0x0582, 0x0000),
 152         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 153                 .vendor_name = "Roland",
 154                 .product_name = "UA-100",
 155                 .ifnum = QUIRK_ANY_INTERFACE,
 156                 .type = QUIRK_COMPOSITE,
 157                 .data = (const snd_usb_audio_quirk_t[]) {
 158                         {
 159                                 .ifnum = 0,
 160                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 161                                 .data = & (const struct audioformat) {
 162                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 163                                         .channels = 4,
 164                                         .iface = 0,
 165                                         .altsetting = 1,
 166                                         .altset_idx = 1,
 167                                         .attributes = 0,
 168                                         .endpoint = 0x01,
 169                                         .ep_attr = 0x09,
 170                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 171                                         .rate_min = 44100,
 172                                         .rate_max = 44100,
 173                                 }
 174                         },
 175                         {
 176                                 .ifnum = 1,
 177                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 178                                 .data = & (const struct audioformat) {
 179                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 180                                         .channels = 2,
 181                                         .iface = 1,
 182                                         .altsetting = 1,
 183                                         .altset_idx = 1,
 184                                         .attributes = EP_CS_ATTR_FILL_MAX,
 185                                         .endpoint = 0x81,
 186                                         .ep_attr = 0x05,
 187                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 188                                         .rate_min = 44100,
 189                                         .rate_max = 44100,
 190                                 }
 191                         },
 192                         {
 193                                 .ifnum = 2,
 194                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 195                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 196                                         .out_cables = 0x0007,
 197                                         .in_cables  = 0x0007
 198                                 }
 199                         },
 200                         {
 201                                 .ifnum = -1
 202                         }
 203                 }
 204         }
 205 },
 206 {
 207         USB_DEVICE(0x0582, 0x0002),
 208         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 209                 .vendor_name = "EDIROL",
 210                 .product_name = "UM-4",
 211                 .ifnum = QUIRK_ANY_INTERFACE,
 212                 .type = QUIRK_COMPOSITE,
 213                 .data = (const snd_usb_audio_quirk_t[]) {
 214                         {
 215                                 .ifnum = 0,
 216                                 .type = QUIRK_IGNORE_INTERFACE
 217                         },
 218                         {
 219                                 .ifnum = 1,
 220                                 .type = QUIRK_IGNORE_INTERFACE
 221                         },
 222                         {
 223                                 .ifnum = 2,
 224                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 225                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 226                                         .out_cables = 0x000f,
 227                                         .in_cables  = 0x000f
 228                                 }
 229                         },
 230                         {
 231                                 .ifnum = -1
 232                         }
 233                 }
 234         }
 235 },
 236 {
 237         USB_DEVICE(0x0582, 0x0003),
 238         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 239                 .vendor_name = "Roland",
 240                 .product_name = "SC-8850",
 241                 .ifnum = QUIRK_ANY_INTERFACE,
 242                 .type = QUIRK_COMPOSITE,
 243                 .data = (const snd_usb_audio_quirk_t[]) {
 244                         {
 245                                 .ifnum = 0,
 246                                 .type = QUIRK_IGNORE_INTERFACE
 247                         },
 248                         {
 249                                 .ifnum = 1,
 250                                 .type = QUIRK_IGNORE_INTERFACE
 251                         },
 252                         {
 253                                 .ifnum = 2,
 254                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 255                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 256                                         .out_cables = 0x003f,
 257                                         .in_cables  = 0x003f
 258                                 }
 259                         },
 260                         {
 261                                 .ifnum = -1
 262                         }
 263                 }
 264         }
 265 },
 266 {
 267         USB_DEVICE(0x0582, 0x0004),
 268         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 269                 .vendor_name = "Roland",
 270                 .product_name = "U-8",
 271                 .ifnum = QUIRK_ANY_INTERFACE,
 272                 .type = QUIRK_COMPOSITE,
 273                 .data = (const snd_usb_audio_quirk_t[]) {
 274                         {
 275                                 .ifnum = 0,
 276                                 .type = QUIRK_IGNORE_INTERFACE
 277                         },
 278                         {
 279                                 .ifnum = 1,
 280                                 .type = QUIRK_IGNORE_INTERFACE
 281                         },
 282                         {
 283                                 .ifnum = 2,
 284                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 285                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 286                                         .out_cables = 0x0005,
 287                                         .in_cables  = 0x0005
 288                                 }
 289                         },
 290                         {
 291                                 .ifnum = -1
 292                         }
 293                 }
 294         }
 295 },
 296 {
 297         USB_DEVICE(0x0582, 0x0005),
 298         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 299                 .vendor_name = "EDIROL",
 300                 .product_name = "UM-2",
 301                 .ifnum = QUIRK_ANY_INTERFACE,
 302                 .type = QUIRK_COMPOSITE,
 303                 .data = (const snd_usb_audio_quirk_t[]) {
 304                         {
 305                                 .ifnum = 0,
 306                                 .type = QUIRK_IGNORE_INTERFACE
 307                         },
 308                         {
 309                                 .ifnum = 1,
 310                                 .type = QUIRK_IGNORE_INTERFACE
 311                         },
 312                         {
 313                                 .ifnum = 2,
 314                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 315                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 316                                         .out_cables = 0x0003,
 317                                         .in_cables  = 0x0003
 318                                 }
 319                         },
 320                         {
 321                                 .ifnum = -1
 322                         }
 323                 }
 324         }
 325 },
 326 {
 327         USB_DEVICE(0x0582, 0x0007),
 328         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 329                 .vendor_name = "Roland",
 330                 .product_name = "SC-8820",
 331                 .ifnum = QUIRK_ANY_INTERFACE,
 332                 .type = QUIRK_COMPOSITE,
 333                 .data = (const snd_usb_audio_quirk_t[]) {
 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 snd_usb_midi_endpoint_info_t) {
 346                                         .out_cables = 0x0013,
 347                                         .in_cables  = 0x0013
 348                                 }
 349                         },
 350                         {
 351                                 .ifnum = -1
 352                         }
 353                 }
 354         }
 355 },
 356 {
 357         USB_DEVICE(0x0582, 0x0008),
 358         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 359                 .vendor_name = "Roland",
 360                 .product_name = "PC-300",
 361                 .ifnum = QUIRK_ANY_INTERFACE,
 362                 .type = QUIRK_COMPOSITE,
 363                 .data = (const snd_usb_audio_quirk_t[]) {
 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 snd_usb_midi_endpoint_info_t) {
 376                                         .out_cables = 0x0001,
 377                                         .in_cables  = 0x0001
 378                                 }
 379                         },
 380                         {
 381                                 .ifnum = -1
 382                         }
 383                 }
 384         }
 385 },
 386 {
 387         USB_DEVICE(0x0582, 0x0009),
 388         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 389                 .vendor_name = "EDIROL",
 390                 .product_name = "UM-1",
 391                 .ifnum = QUIRK_ANY_INTERFACE,
 392                 .type = QUIRK_COMPOSITE,
 393                 .data = (const snd_usb_audio_quirk_t[]) {
 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 snd_usb_midi_endpoint_info_t) {
 406                                         .out_cables = 0x0001,
 407                                         .in_cables  = 0x0001
 408                                 }
 409                         },
 410                         {
 411                                 .ifnum = -1
 412                         }
 413                 }
 414         }
 415 },
 416 {
 417         USB_DEVICE(0x0582, 0x000b),
 418         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 419                 .vendor_name = "Roland",
 420                 .product_name = "SK-500",
 421                 .ifnum = QUIRK_ANY_INTERFACE,
 422                 .type = QUIRK_COMPOSITE,
 423                 .data = (const snd_usb_audio_quirk_t[]) {
 424                         {
 425                                 .ifnum = 0,
 426                                 .type = QUIRK_IGNORE_INTERFACE
 427                         },
 428                         {
 429                                 .ifnum = 1,
 430                                 .type = QUIRK_IGNORE_INTERFACE
 431                         },
 432                         {
 433                                 .ifnum = 2,
 434                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 435                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 436                                         .out_cables = 0x0013,
 437                                         .in_cables  = 0x0013
 438                                 }
 439                         },
 440                         {
 441                                 .ifnum = -1
 442                         }
 443                 }
 444         }
 445 },
 446 {
 447         /* thanks to Emiliano Grilli <emillo@libero.it>
 448          * for helping researching this data */
 449         USB_DEVICE(0x0582, 0x000c),
 450         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 451                 .vendor_name = "Roland",
 452                 .product_name = "SC-D70",
 453                 .ifnum = QUIRK_ANY_INTERFACE,
 454                 .type = QUIRK_COMPOSITE,
 455                 .data = (const snd_usb_audio_quirk_t[]) {
 456                         {
 457                                 .ifnum = 0,
 458                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 459                                 .data = & (const struct audioformat) {
 460                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 461                                         .channels = 2,
 462                                         .iface = 0,
 463                                         .altsetting = 1,
 464                                         .altset_idx = 1,
 465                                         .attributes = 0,
 466                                         .endpoint = 0x01,
 467                                         .ep_attr = 0x01,
 468                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 469                                         .rate_min = 44100,
 470                                         .rate_max = 44100,
 471                                 }
 472                         },
 473                         {
 474                                 .ifnum = 1,
 475                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 476                                 .data = & (const struct audioformat) {
 477                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 478                                         .channels = 2,
 479                                         .iface = 1,
 480                                         .altsetting = 1,
 481                                         .altset_idx = 1,
 482                                         .attributes = 0,
 483                                         .endpoint = 0x81,
 484                                         .ep_attr = 0x01,
 485                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 486                                         .rate_min = 44100,
 487                                         .rate_max = 44100,
 488                                 }
 489                         },
 490                         {
 491                                 .ifnum = 2,
 492                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 493                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 494                                         .out_cables = 0x0007,
 495                                         .in_cables  = 0x0007
 496                                 }
 497                         },
 498                         {
 499                                 .ifnum = -1
 500                         }
 501                 }
 502         }
 503 },
 504 {       /*
 505          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 506          * If the advanced mode switch at the back of the unit is off, the
 507          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 508          * but offers only 16-bit PCM.
 509          * In advanced mode, the UA-5 will output S24_3LE samples (two
 510          * channels) at the rate indicated on the front switch, including
 511          * the 96kHz sample rate.
 512          */
 513         USB_DEVICE(0x0582, 0x0010),
 514         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 515                 .vendor_name = "EDIROL",
 516                 .product_name = "UA-5",
 517                 .ifnum = QUIRK_ANY_INTERFACE,
 518                 .type = QUIRK_COMPOSITE,
 519                 .data = (const snd_usb_audio_quirk_t[]) {
 520                         {
 521                                 .ifnum = 1,
 522                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 523                         },
 524                         {
 525                                 .ifnum = 2,
 526                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 527                         },
 528                         {
 529                                 .ifnum = -1
 530                         }
 531                 }
 532         }
 533 },
 534 {
 535         USB_DEVICE(0x0582, 0x0012),
 536         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 537                 .vendor_name = "Roland",
 538                 .product_name = "XV-5050",
 539                 .ifnum = 0,
 540                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 541                 .data = & (const snd_usb_midi_endpoint_info_t) {
 542                         .out_cables = 0x0001,
 543                         .in_cables  = 0x0001
 544                 }
 545         }
 546 },
 547 {
 548         USB_DEVICE(0x0582, 0x0014),
 549         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 550                 .vendor_name = "EDIROL",
 551                 .product_name = "UM-880",
 552                 .ifnum = 0,
 553                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 554                 .data = & (const snd_usb_midi_endpoint_info_t) {
 555                         .out_cables = 0x01ff,
 556                         .in_cables  = 0x01ff
 557                 }
 558         }
 559 },
 560 {
 561         USB_DEVICE(0x0582, 0x0016),
 562         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 563                 .vendor_name = "EDIROL",
 564                 .product_name = "SD-90",
 565                 .ifnum = QUIRK_ANY_INTERFACE,
 566                 .type = QUIRK_COMPOSITE,
 567                 .data = (const snd_usb_audio_quirk_t[]) {
 568                         {
 569                                 .ifnum = 0,
 570                                 .type = QUIRK_IGNORE_INTERFACE
 571                         },
 572                         {
 573                                 .ifnum = 1,
 574                                 .type = QUIRK_IGNORE_INTERFACE
 575                         },
 576                         {
 577                                 .ifnum = 2,
 578                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 579                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 580                                         .out_cables = 0x000f,
 581                                         .in_cables  = 0x000f
 582                                 }
 583                         },
 584                         {
 585                                 .ifnum = -1
 586                         }
 587                 }
 588         }
 589 },
 590 {
 591         USB_DEVICE(0x0582, 0x001b),
 592         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 593                 .vendor_name = "Roland",
 594                 .product_name = "MMP-2",
 595                 .ifnum = QUIRK_ANY_INTERFACE,
 596                 .type = QUIRK_COMPOSITE,
 597                 .data = (const snd_usb_audio_quirk_t[]) {
 598                         {
 599                                 .ifnum = 0,
 600                                 .type = QUIRK_IGNORE_INTERFACE
 601                         },
 602                         {
 603                                 .ifnum = 1,
 604                                 .type = QUIRK_IGNORE_INTERFACE
 605                         },
 606                         {
 607                                 .ifnum = 2,
 608                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 609                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 610                                         .out_cables = 0x0001,
 611                                         .in_cables  = 0x0001
 612                                 }
 613                         },
 614                         {
 615                                 .ifnum = -1
 616                         }
 617                 }
 618         }
 619 },
 620 {
 621         USB_DEVICE(0x0582, 0x001d),
 622         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 623                 .vendor_name = "Roland",
 624                 .product_name = "V-SYNTH",
 625                 .ifnum = 0,
 626                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 627                 .data = & (const snd_usb_midi_endpoint_info_t) {
 628                         .out_cables = 0x0001,
 629                         .in_cables  = 0x0001
 630                 }
 631         }
 632 },
 633 {
 634         USB_DEVICE(0x0582, 0x0023),
 635         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 636                 .vendor_name = "EDIROL",
 637                 .product_name = "UM-550",
 638                 .ifnum = 0,
 639                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 640                 .data = & (const snd_usb_midi_endpoint_info_t) {
 641                         .out_cables = 0x003f,
 642                         .in_cables  = 0x003f
 643                 }
 644         }
 645 },
 646 {
 647         /*
 648          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 649          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 650          * and no MIDI.
 651          */
 652         USB_DEVICE(0x0582, 0x0025),
 653         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 654                 .vendor_name = "EDIROL",
 655                 .product_name = "UA-20",
 656                 .ifnum = QUIRK_ANY_INTERFACE,
 657                 .type = QUIRK_COMPOSITE,
 658                 .data = (const snd_usb_audio_quirk_t[]) {
 659                         {
 660                                 .ifnum = 1,
 661                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 662                         },
 663                         {
 664                                 .ifnum = 2,
 665                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 666                         },
 667                         {
 668                                 .ifnum = 3,
 669                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 670                         },
 671                         {
 672                                 .ifnum = -1
 673                         }
 674                 }
 675         }
 676 },
 677 {
 678         USB_DEVICE(0x0582, 0x0027),
 679         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 680                 .vendor_name = "EDIROL",
 681                 .product_name = "SD-20",
 682                 .ifnum = 0,
 683                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 684                 .data = & (const snd_usb_midi_endpoint_info_t) {
 685                         .out_cables = 0x0003,
 686                         .in_cables  = 0x0007
 687                 }
 688         }
 689 },
 690 {
 691         USB_DEVICE(0x0582, 0x0029),
 692         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 693                 .vendor_name = "EDIROL",
 694                 .product_name = "SD-80",
 695                 .ifnum = 0,
 696                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 697                 .data = & (const snd_usb_midi_endpoint_info_t) {
 698                         .out_cables = 0x000f,
 699                         .in_cables  = 0x000f
 700                 }
 701         }
 702 },
 703 {       /*
 704          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 705          * If the sample format switch is not in an advanced setting, the
 706          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 707          * but offers only 16-bit PCM and no MIDI.
 708          */
 709         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 710         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 711                 .vendor_name = "EDIROL",
 712                 .product_name = "UA-700",
 713                 .ifnum = QUIRK_ANY_INTERFACE,
 714                 .type = QUIRK_COMPOSITE,
 715                 .data = (const snd_usb_audio_quirk_t[]) {
 716                         {
 717                                 .ifnum = 1,
 718                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 719                         },
 720                         {
 721                                 .ifnum = 2,
 722                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 723                         },
 724                         {
 725                                 .ifnum = 3,
 726                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 727                         },
 728                         {
 729                                 .ifnum = -1
 730                         }
 731                 }
 732         }
 733 },
 734 {
 735         USB_DEVICE(0x0582, 0x002d),
 736         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 737                 .vendor_name = "Roland",
 738                 .product_name = "XV-2020",
 739                 .ifnum = 0,
 740                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 741                 .data = & (const snd_usb_midi_endpoint_info_t) {
 742                         .out_cables = 0x0001,
 743                         .in_cables  = 0x0001
 744                 }
 745         }
 746 },
 747 {
 748         USB_DEVICE(0x0582, 0x002f),
 749         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 750                 .vendor_name = "Roland",
 751                 .product_name = "VariOS",
 752                 .ifnum = 0,
 753                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 754                 .data = & (const snd_usb_midi_endpoint_info_t) {
 755                         .out_cables = 0x0007,
 756                         .in_cables  = 0x0007
 757                 }
 758         }
 759 },
 760 {
 761         USB_DEVICE(0x0582, 0x0033),
 762         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 763                 .vendor_name = "EDIROL",
 764                 .product_name = "PCR",
 765                 .ifnum = 0,
 766                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 767                 .data = & (const snd_usb_midi_endpoint_info_t) {
 768                         .out_cables = 0x0003,
 769                         .in_cables  = 0x0007
 770                 }
 771         }
 772 },
 773 {
 774         USB_DEVICE(0x0582, 0x0037),
 775         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 776                 .vendor_name = "Roland",
 777                 .product_name = "Digital Piano",
 778                 .ifnum = 0,
 779                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 780                 .data = & (const snd_usb_midi_endpoint_info_t) {
 781                         .out_cables = 0x0001,
 782                         .in_cables  = 0x0001
 783                 }
 784         }
 785 },
 786 {
 787         /*
 788          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
 789          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
 790          * and no MIDI.
 791          */
 792         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 793         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 794                 .vendor_name = "BOSS",
 795                 .product_name = "GS-10",
 796                 .ifnum = QUIRK_ANY_INTERFACE,
 797                 .type = QUIRK_COMPOSITE,
 798                 .data = & (const snd_usb_audio_quirk_t[]) {
 799                         {
 800                                 .ifnum = 1,
 801                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 802                         },
 803                         {
 804                                 .ifnum = 2,
 805                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 806                         },
 807                         {
 808                                 .ifnum = 3,
 809                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 810                         },
 811                         {
 812                                 .ifnum = -1
 813                         }
 814                 }
 815         }
 816 },
 817 {
 818         USB_DEVICE(0x0582, 0x0040),
 819         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 820                 .vendor_name = "Roland",
 821                 .product_name = "GI-20",
 822                 .ifnum = 0,
 823                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 824                 .data = & (const snd_usb_midi_endpoint_info_t) {
 825                         .out_cables = 0x0001,
 826                         .in_cables  = 0x0001
 827                 }
 828         }
 829 },
 830 {
 831         USB_DEVICE(0x0582, 0x0042),
 832         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 833                 .vendor_name = "Roland",
 834                 .product_name = "RS-70",
 835                 .ifnum = 0,
 836                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 837                 .data = & (const snd_usb_midi_endpoint_info_t) {
 838                         .out_cables = 0x0001,
 839                         .in_cables  = 0x0001
 840                 }
 841         }
 842 },
 843 {
 844         USB_DEVICE(0x0582, 0x0044),
 845         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 846                 .vendor_name = "Roland",
 847                 .product_name = "UA-1000",
 848                 .ifnum = QUIRK_ANY_INTERFACE,
 849                 .type = QUIRK_COMPOSITE,
 850                 .data = (const snd_usb_audio_quirk_t[]) {
 851                         {
 852                                 .ifnum = 1,
 853                                 .type = QUIRK_AUDIO_EDIROL_UA1000
 854                         },
 855                         {
 856                                 .ifnum = 2,
 857                                 .type = QUIRK_AUDIO_EDIROL_UA1000
 858                         },
 859                         {
 860                                 .ifnum = 3,
 861                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 862                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 863                                         .out_cables = 0x0003,
 864                                         .in_cables  = 0x0003
 865                                 }
 866                         },
 867                         {
 868                                 .ifnum = -1
 869                         }
 870                 }
 871         }
 872 },
 873 {
 874         USB_DEVICE(0x0582, 0x0048),
 875         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 876                 .vendor_name = "EDIROL",
 877                 .product_name = "UR-80",
 878                 .ifnum = 0,
 879                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 880                 .data = & (const snd_usb_midi_endpoint_info_t) {
 881                         .out_cables = 0x0003,
 882                         .in_cables  = 0x0007
 883                 }
 884         }
 885 },
 886 {
 887         USB_DEVICE(0x0582, 0x004d),
 888         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 889                 .vendor_name = "EDIROL",
 890                 .product_name = "PCR-A",
 891                 .ifnum = 0,
 892                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 893                 .data = & (const snd_usb_midi_endpoint_info_t) {
 894                         .out_cables = 0x0003,
 895                         .in_cables  = 0x0007
 896                 }
 897         }
 898 },
 899 {
 900         /*
 901          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
 902          * is standard compliant, but has only 16-bit PCM.
 903          */
 904         USB_DEVICE(0x0582, 0x0050),
 905         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 906                 .vendor_name = "EDIROL",
 907                 .product_name = "UA-3FX",
 908                 .ifnum = QUIRK_ANY_INTERFACE,
 909                 .type = QUIRK_COMPOSITE,
 910                 .data = (const snd_usb_audio_quirk_t[]) {
 911                         {
 912                                 .ifnum = 1,
 913                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 914                         },
 915                         {
 916                                 .ifnum = 2,
 917                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 918                         },
 919                         {
 920                                 .ifnum = -1
 921                         }
 922                 }
 923         }
 924 },
 925 {
 926         USB_DEVICE(0x0582, 0x0052),
 927         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 928                 .vendor_name = "EDIROL",
 929                 .product_name = "UM-1SX",
 930                 .ifnum = 0,
 931                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 932         }
 933 },
 934 {
 935         USB_DEVICE(0x0582, 0x0065),
 936         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 937                 .vendor_name = "EDIROL",
 938                 .product_name = "PCR-1",
 939                 .ifnum = 0,
 940                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 941                 .data = & (const snd_usb_midi_endpoint_info_t) {
 942                         .out_cables = 0x0001,
 943                         .in_cables  = 0x0003
 944                 }
 945         }
 946 },
 947 {
 948         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
 949         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 950                 .vendor_name = "Roland",
 951                 .product_name = "SP-606",
 952                 .ifnum = 3,
 953                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 954                 .data = & (const snd_usb_midi_endpoint_info_t) {
 955                         .out_cables = 0x0001,
 956                         .in_cables  = 0x0001
 957                 }
 958         }
 959 },
 960 {
 961         USB_DEVICE(0x0582, 0x006d),
 962         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 963                 .vendor_name = "Roland",
 964                 .product_name = "FANTOM-X",
 965                 .ifnum = 0,
 966                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 967                 .data = & (const snd_usb_midi_endpoint_info_t) {
 968                         .out_cables = 0x0001,
 969                         .in_cables  = 0x0001
 970                 }
 971         }
 972 },
 973 {       /*
 974          * This quirk is for the "Advanced" modes of the Edirol UA-25.
 975          * If the switch is not in an advanced setting, the UA-25 has
 976          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
 977          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
 978          */
 979         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
 980         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 981                 .vendor_name = "EDIROL",
 982                 .product_name = "UA-25",
 983                 .ifnum = QUIRK_ANY_INTERFACE,
 984                 .type = QUIRK_COMPOSITE,
 985                 .data = (const snd_usb_audio_quirk_t[]) {
 986                         {
 987                                 .ifnum = 0,
 988                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 989                         },
 990                         {
 991                                 .ifnum = 1,
 992                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 993                         },
 994                         {
 995                                 .ifnum = 2,
 996                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 997                         },
 998                         {
 999                                 .ifnum = -1
1000                         }
1001                 }
1002         }
1003 },
1004 {
1005         USB_DEVICE(0x0582, 0x0075),
1006         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1007                 .vendor_name = "BOSS",
1008                 .product_name = "DR-880",
1009                 .ifnum = 0,
1010                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1011                 .data = & (const snd_usb_midi_endpoint_info_t) {
1012                         .out_cables = 0x0001,
1013                         .in_cables  = 0x0001
1014                 }
1015         }
1016 },
1017 {
1018         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1019         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1020                 .vendor_name = "Roland",
1021                 /* RD-700SX, RD-300SX */
1022                 .ifnum = 0,
1023                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1024                 .data = & (const snd_usb_midi_endpoint_info_t) {
1025                         .out_cables = 0x0003,
1026                         .in_cables  = 0x0003
1027                 }
1028         }
1029 },
1030
1031 /* Guillemot devices */
1032 {
1033         /*
1034          * This is for the "Windows Edition" where the external MIDI ports are
1035          * the only MIDI ports; the control data is reported through HID
1036          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1037          * compliant USB MIDI ports for external MIDI and controls.
1038          */
1039         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1040         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1041                 .vendor_name = "Hercules",
1042                 .product_name = "DJ Console (WE)",
1043                 .ifnum = 4,
1044                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1045                 .data = & (const snd_usb_midi_endpoint_info_t) {
1046                         .out_cables = 0x0001,
1047                         .in_cables = 0x0001
1048                 }
1049         }
1050 },
1051
1052 /* Midiman/M-Audio devices */
1053 {
1054         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1055         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1056                 .vendor_name = "M-Audio",
1057                 .product_name = "MidiSport 2x2",
1058                 .ifnum = QUIRK_ANY_INTERFACE,
1059                 .type = QUIRK_MIDI_MIDIMAN,
1060                 .data = & (const snd_usb_midi_endpoint_info_t) {
1061                         .out_cables = 0x0003,
1062                         .in_cables  = 0x0003
1063                 }
1064         }
1065 },
1066 {
1067         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1068         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1069                 .vendor_name = "M-Audio",
1070                 .product_name = "MidiSport 1x1",
1071                 .ifnum = QUIRK_ANY_INTERFACE,
1072                 .type = QUIRK_MIDI_MIDIMAN,
1073                 .data = & (const snd_usb_midi_endpoint_info_t) {
1074                         .out_cables = 0x0001,
1075                         .in_cables  = 0x0001
1076                 }
1077         }
1078 },
1079 {
1080         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1081         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1082                 .vendor_name = "M-Audio",
1083                 .product_name = "Keystation",
1084                 .ifnum = QUIRK_ANY_INTERFACE,
1085                 .type = QUIRK_MIDI_MIDIMAN,
1086                 .data = & (const snd_usb_midi_endpoint_info_t) {
1087                         .out_cables = 0x0001,
1088                         .in_cables  = 0x0001
1089                 }
1090         }
1091 },
1092 {
1093         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1094         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1095                 .vendor_name = "M-Audio",
1096                 .product_name = "MidiSport 4x4",
1097                 .ifnum = QUIRK_ANY_INTERFACE,
1098                 .type = QUIRK_MIDI_MIDIMAN,
1099                 .data = & (const snd_usb_midi_endpoint_info_t) {
1100                         .out_cables = 0x000f,
1101                         .in_cables  = 0x000f
1102                 }
1103         }
1104 },
1105 {
1106         /*
1107          * For hardware revision 1.05; in the later revisions (1.10 and
1108          * 1.21), 0x1031 is the ID for the device without firmware.
1109          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1110          */
1111         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1112         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1113                 .vendor_name = "M-Audio",
1114                 .product_name = "MidiSport 8x8",
1115                 .ifnum = QUIRK_ANY_INTERFACE,
1116                 .type = QUIRK_MIDI_MIDIMAN,
1117                 .data = & (const snd_usb_midi_endpoint_info_t) {
1118                         .out_cables = 0x01ff,
1119                         .in_cables  = 0x01ff
1120                 }
1121         }
1122 },
1123 {
1124         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1125         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1126                 .vendor_name = "M-Audio",
1127                 .product_name = "MidiSport 8x8",
1128                 .ifnum = QUIRK_ANY_INTERFACE,
1129                 .type = QUIRK_MIDI_MIDIMAN,
1130                 .data = & (const snd_usb_midi_endpoint_info_t) {
1131                         .out_cables = 0x01ff,
1132                         .in_cables  = 0x01ff
1133                 }
1134         }
1135 },
1136 {
1137         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1138         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1139                 .vendor_name = "M-Audio",
1140                 .product_name = "MidiSport 2x4",
1141                 .ifnum = QUIRK_ANY_INTERFACE,
1142                 .type = QUIRK_MIDI_MIDIMAN,
1143                 .data = & (const snd_usb_midi_endpoint_info_t) {
1144                         .out_cables = 0x000f,
1145                         .in_cables  = 0x0003
1146                 }
1147         }
1148 },
1149 {
1150         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1151         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1152                 .vendor_name = "M-Audio",
1153                 .product_name = "Quattro",
1154                 .ifnum = QUIRK_ANY_INTERFACE,
1155                 .type = QUIRK_COMPOSITE,
1156                 .data = & (const snd_usb_audio_quirk_t[]) {
1157                         /*
1158                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1159                          * and share endpoints with the other interfaces.
1160                          * Ignore them.  The other interfaces can do 24 bits,
1161                          * but captured samples are big-endian (see usbaudio.c).
1162                          */
1163                         {
1164                                 .ifnum = 0,
1165                                 .type = QUIRK_IGNORE_INTERFACE
1166                         },
1167                         {
1168                                 .ifnum = 1,
1169                                 .type = QUIRK_IGNORE_INTERFACE
1170                         },
1171                         {
1172                                 .ifnum = 2,
1173                                 .type = QUIRK_IGNORE_INTERFACE
1174                         },
1175                         {
1176                                 .ifnum = 3,
1177                                 .type = QUIRK_IGNORE_INTERFACE
1178                         },
1179                         {
1180                                 .ifnum = 4,
1181                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1182                         },
1183                         {
1184                                 .ifnum = 5,
1185                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1186                         },
1187                         {
1188                                 .ifnum = 6,
1189                                 .type = QUIRK_IGNORE_INTERFACE
1190                         },
1191                         {
1192                                 .ifnum = 7,
1193                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1194                         },
1195                         {
1196                                 .ifnum = 8,
1197                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1198                         },
1199                         {
1200                                 .ifnum = 9,
1201                                 .type = QUIRK_MIDI_MIDIMAN,
1202                                 .data = & (const snd_usb_midi_endpoint_info_t) {
1203                                         .out_cables = 0x0001,
1204                                         .in_cables  = 0x0001
1205                                 }
1206                         },
1207                         {
1208                                 .ifnum = -1
1209                         }
1210                 }
1211         }
1212 },
1213 {
1214         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1215         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1216                 .vendor_name = "M-Audio",
1217                 .product_name = "AudioPhile",
1218                 .ifnum = 6,
1219                 .type = QUIRK_MIDI_MIDIMAN,
1220                 .data = & (const snd_usb_midi_endpoint_info_t) {
1221                         .out_cables = 0x0001,
1222                         .in_cables  = 0x0001
1223                 }
1224         }
1225 },
1226 {
1227         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1228         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1229                 .vendor_name = "M-Audio",
1230                 .product_name = "Ozone",
1231                 .ifnum = 3,
1232                 .type = QUIRK_MIDI_MIDIMAN,
1233                 .data = & (const snd_usb_midi_endpoint_info_t) {
1234                         .out_cables = 0x0001,
1235                         .in_cables  = 0x0001
1236                 }
1237         }
1238 },
1239 {
1240         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1241         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1242                 .vendor_name = "M-Audio",
1243                 .product_name = "OmniStudio",
1244                 .ifnum = QUIRK_ANY_INTERFACE,
1245                 .type = QUIRK_COMPOSITE,
1246                 .data = & (const snd_usb_audio_quirk_t[]) {
1247                         {
1248                                 .ifnum = 0,
1249                                 .type = QUIRK_IGNORE_INTERFACE
1250                         },
1251                         {
1252                                 .ifnum = 1,
1253                                 .type = QUIRK_IGNORE_INTERFACE
1254                         },
1255                         {
1256                                 .ifnum = 2,
1257                                 .type = QUIRK_IGNORE_INTERFACE
1258                         },
1259                         {
1260                                 .ifnum = 3,
1261                                 .type = QUIRK_IGNORE_INTERFACE
1262                         },
1263                         {
1264                                 .ifnum = 4,
1265                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1266                         },
1267                         {
1268                                 .ifnum = 5,
1269                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1270                         },
1271                         {
1272                                 .ifnum = 6,
1273                                 .type = QUIRK_IGNORE_INTERFACE
1274                         },
1275                         {
1276                                 .ifnum = 7,
1277                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1278                         },
1279                         {
1280                                 .ifnum = 8,
1281                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1282                         },
1283                         {
1284                                 .ifnum = 9,
1285                                 .type = QUIRK_MIDI_MIDIMAN,
1286                                 .data = & (const snd_usb_midi_endpoint_info_t) {
1287                                         .out_cables = 0x0001,
1288                                         .in_cables  = 0x0001
1289                                 }
1290                         },
1291                         {
1292                                 .ifnum = -1
1293                         }
1294                 }
1295         }
1296 },
1297
1298 /* Mark of the Unicorn devices */
1299 {
1300         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1301         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1302                        USB_DEVICE_ID_MATCH_PRODUCT |
1303                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1304         .idVendor = 0x07fd,
1305         .idProduct = 0x0001,
1306         .bDeviceSubClass = 2,
1307         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1308                 .vendor_name = "MOTU",
1309                 .product_name = "Fastlane",
1310                 .ifnum = QUIRK_ANY_INTERFACE,
1311                 .type = QUIRK_COMPOSITE,
1312                 .data = & (const snd_usb_audio_quirk_t[]) {
1313                         {
1314                                 .ifnum = 0,
1315                                 .type = QUIRK_MIDI_RAW
1316                         },
1317                         {
1318                                 .ifnum = 1,
1319                                 .type = QUIRK_IGNORE_INTERFACE
1320                         },
1321                         {
1322                                 .ifnum = -1
1323                         }
1324                 }
1325         }
1326 },
1327
1328 {
1329         /* Creative Sound Blaster MP3+ */
1330         USB_DEVICE(0x041e, 0x3010),
1331         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1332                 .vendor_name = "Creative Labs",
1333                 .product_name = "Sound Blaster MP3+",
1334                 .ifnum = QUIRK_NO_INTERFACE
1335         }
1336
1337 },
1338
1339 /* Emagic devices */
1340 {
1341         USB_DEVICE(0x086a, 0x0001),
1342         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1343                 .vendor_name = "Emagic",
1344                 /* .product_name = "Unitor8", */
1345                 .ifnum = 2,
1346                 .type = QUIRK_MIDI_EMAGIC,
1347                 .data = & (const snd_usb_midi_endpoint_info_t) {
1348                         .out_cables = 0x80ff,
1349                         .in_cables  = 0x80ff
1350                 }
1351         }
1352 },
1353 {
1354         USB_DEVICE(0x086a, 0x0002),
1355         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1356                 .vendor_name = "Emagic",
1357                 /* .product_name = "AMT8", */
1358                 .ifnum = 2,
1359                 .type = QUIRK_MIDI_EMAGIC,
1360                 .data = & (const snd_usb_midi_endpoint_info_t) {
1361                         .out_cables = 0x80ff,
1362                         .in_cables  = 0x80ff
1363                 }
1364         }
1365 },
1366 {
1367         USB_DEVICE(0x086a, 0x0003),
1368         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1369                 .vendor_name = "Emagic",
1370                 /* .product_name = "MT4", */
1371                 .ifnum = 2,
1372                 .type = QUIRK_MIDI_EMAGIC,
1373                 .data = & (const snd_usb_midi_endpoint_info_t) {
1374                         .out_cables = 0x800f,
1375                         .in_cables  = 0x8003
1376                 }
1377         }
1378 },
1379
1380 /* TerraTec devices */
1381 {
1382         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1383         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1384                 .vendor_name = "TerraTec",
1385                 .product_name = "PHASE 26",
1386                 .ifnum = 3,
1387                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1388         }
1389 },
1390 {
1391         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1392         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1393                 .vendor_name = "TerraTec",
1394                 .product_name = "PHASE 26",
1395                 .ifnum = 3,
1396                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1397         }
1398 },
1399
1400 /* Novation EMS devices */
1401 {
1402         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1403         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1404                 .vendor_name = "Novation",
1405                 .product_name = "ReMOTE Audio/XStation",
1406                 .ifnum = 4,
1407                 .type = QUIRK_MIDI_NOVATION
1408         }
1409 },
1410 {
1411         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1412         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1413                 .vendor_name = "Novation",
1414                 .product_name = "Speedio",
1415                 .ifnum = 3,
1416                 .type = QUIRK_MIDI_NOVATION
1417         }
1418 },
1419 {
1420         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1421         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1422                 .vendor_name = "Novation",
1423                 .product_name = "ReMOTE25",
1424                 .ifnum = 0,
1425                 .type = QUIRK_MIDI_NOVATION
1426         }
1427 },
1428
1429 {
1430         USB_DEVICE(0x4752, 0x0011),
1431         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1432                 .vendor_name = "Miditech",
1433                 .product_name = "Midistart-2",
1434                 .ifnum = 0,
1435                 .type = QUIRK_MIDI_MIDITECH
1436         }
1437 },
1438 {
1439         USB_DEVICE(0x7104, 0x2202),
1440         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1441                 .vendor_name = "Miditech",
1442                 .product_name = "MidiStudio-2",
1443                 .ifnum = 0,
1444                 .type = QUIRK_MIDI_MIDITECH
1445         }
1446 },
1447
1448 {
1449         /*
1450          * Some USB MIDI devices don't have an audio control interface,
1451          * so we have to grab MIDI streaming interfaces here.
1452          */
1453         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1454                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1455         .bInterfaceClass = USB_CLASS_AUDIO,
1456         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1457         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1458                 .ifnum = QUIRK_ANY_INTERFACE,
1459                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1460         }
1461 },
1462
1463 #undef USB_DEVICE_VENDOR_SPEC