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