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