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