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