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