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