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