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