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 0x0049 when not in "Advanced Driver" mode */
1008         USB_DEVICE(0x0582, 0x0047),
1009         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1010                 /* .vendor_name = "EDIROL", */
1011                 /* .product_name = "UR-80", */
1012                 .ifnum = QUIRK_ANY_INTERFACE,
1013                 .type = QUIRK_COMPOSITE,
1014                 .data = (const struct snd_usb_audio_quirk[]) {
1015                         /* in the 96 kHz modes, only interface 1 is there */
1016                         {
1017                                 .ifnum = 1,
1018                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1019                         },
1020                         {
1021                                 .ifnum = 2,
1022                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1023                         },
1024                         {
1025                                 .ifnum = -1
1026                         }
1027                 }
1028         }
1029 },
1030 {
1031         /* has ID 0x004a when not in "Advanced Driver" mode */
1032         USB_DEVICE(0x0582, 0x0048),
1033         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1034                 /* .vendor_name = "EDIROL", */
1035                 /* .product_name = "UR-80", */
1036                 .ifnum = 0,
1037                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1038                 .data = & (const struct snd_usb_midi_endpoint_info) {
1039                         .out_cables = 0x0003,
1040                         .in_cables  = 0x0007
1041                 }
1042         }
1043 },
1044         /* TODO: add Edirol M-100FX support */
1045 {
1046         /* has ID 0x004e when not in "Advanced Driver" mode */
1047         USB_DEVICE(0x0582, 0x004c),
1048         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1049                 .vendor_name = "EDIROL",
1050                 .product_name = "PCR-A",
1051                 .ifnum = QUIRK_ANY_INTERFACE,
1052                 .type = QUIRK_COMPOSITE,
1053                 .data = (const struct snd_usb_audio_quirk[]) {
1054                         {
1055                                 .ifnum = 1,
1056                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1057                         },
1058                         {
1059                                 .ifnum = 2,
1060                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1061                         },
1062                         {
1063                                 .ifnum = -1
1064                         }
1065                 }
1066         }
1067 },
1068 {
1069         /* has ID 0x004f when not in "Advanced Driver" mode */
1070         USB_DEVICE(0x0582, 0x004d),
1071         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1072                 .vendor_name = "EDIROL",
1073                 .product_name = "PCR-A",
1074                 .ifnum = 0,
1075                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1076                 .data = & (const struct snd_usb_midi_endpoint_info) {
1077                         .out_cables = 0x0003,
1078                         .in_cables  = 0x0007
1079                 }
1080         }
1081 },
1082 {
1083         /*
1084          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1085          * is standard compliant, but has only 16-bit PCM.
1086          */
1087         USB_DEVICE(0x0582, 0x0050),
1088         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1089                 .vendor_name = "EDIROL",
1090                 .product_name = "UA-3FX",
1091                 .ifnum = QUIRK_ANY_INTERFACE,
1092                 .type = QUIRK_COMPOSITE,
1093                 .data = (const struct snd_usb_audio_quirk[]) {
1094                         {
1095                                 .ifnum = 1,
1096                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1097                         },
1098                         {
1099                                 .ifnum = 2,
1100                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1101                         },
1102                         {
1103                                 .ifnum = -1
1104                         }
1105                 }
1106         }
1107 },
1108 {
1109         USB_DEVICE(0x0582, 0x0052),
1110         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1111                 .vendor_name = "EDIROL",
1112                 .product_name = "UM-1SX",
1113                 .ifnum = 0,
1114                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1115         }
1116 },
1117 {
1118         USB_DEVICE(0x0582, 0x0060),
1119         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1120                 .vendor_name = "Roland",
1121                 .product_name = "EXR Series",
1122                 .ifnum = 0,
1123                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1124         }
1125 },
1126 {
1127         /* has ID 0x0067 when not in "Advanced Driver" mode */
1128         USB_DEVICE(0x0582, 0x0065),
1129         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1130                 .vendor_name = "EDIROL",
1131                 .product_name = "PCR-1",
1132                 .ifnum = 0,
1133                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1134                 .data = & (const struct snd_usb_midi_endpoint_info) {
1135                         .out_cables = 0x0001,
1136                         .in_cables  = 0x0003
1137                 }
1138         }
1139 },
1140 {
1141         /* has ID 0x006b when not in "Advanced Driver" mode */
1142         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1143         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1144                 .vendor_name = "Roland",
1145                 .product_name = "SP-606",
1146                 .ifnum = 3,
1147                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1148                 .data = & (const struct snd_usb_midi_endpoint_info) {
1149                         .out_cables = 0x0001,
1150                         .in_cables  = 0x0001
1151                 }
1152         }
1153 },
1154 {
1155         /* has ID 0x006e when not in "Advanced Driver" mode */
1156         USB_DEVICE(0x0582, 0x006d),
1157         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1158                 .vendor_name = "Roland",
1159                 .product_name = "FANTOM-X",
1160                 .ifnum = 0,
1161                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1162                 .data = & (const struct snd_usb_midi_endpoint_info) {
1163                         .out_cables = 0x0001,
1164                         .in_cables  = 0x0001
1165                 }
1166         }
1167 },
1168 {
1169         USB_DEVICE(0x582, 0x00a6),
1170         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1171                 .vendor_name = "Roland",
1172                 .product_name = "Juno-G",
1173                 .ifnum = 0,
1174                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1175                 .data = & (const struct snd_usb_midi_endpoint_info) {
1176                         .out_cables = 0x0001,
1177                         .in_cables  = 0x0001
1178                 }
1179         }
1180 },
1181 {       /*
1182          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1183          * If the switch is not in an advanced setting, the UA-25 has
1184          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1185          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1186          */
1187         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1188         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1189                 .vendor_name = "EDIROL",
1190                 .product_name = "UA-25",
1191                 .ifnum = QUIRK_ANY_INTERFACE,
1192                 .type = QUIRK_COMPOSITE,
1193                 .data = (const struct snd_usb_audio_quirk[]) {
1194                         {
1195                                 .ifnum = 0,
1196                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1197                         },
1198                         {
1199                                 .ifnum = 1,
1200                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1201                         },
1202                         {
1203                                 .ifnum = 2,
1204                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1205                         },
1206                         {
1207                                 .ifnum = -1
1208                         }
1209                 }
1210         }
1211 },
1212 {
1213         /* has ID 0x0076 when not in "Advanced Driver" mode */
1214         USB_DEVICE(0x0582, 0x0075),
1215         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1216                 .vendor_name = "BOSS",
1217                 .product_name = "DR-880",
1218                 .ifnum = 0,
1219                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1220                 .data = & (const struct snd_usb_midi_endpoint_info) {
1221                         .out_cables = 0x0001,
1222                         .in_cables  = 0x0001
1223                 }
1224         }
1225 },
1226 {
1227         /* has ID 0x007b when not in "Advanced Driver" mode */
1228         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1229         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1230                 .vendor_name = "Roland",
1231                 /* "RD" or "RD-700SX"? */
1232                 .ifnum = 0,
1233                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1234                 .data = & (const struct snd_usb_midi_endpoint_info) {
1235                         .out_cables = 0x0003,
1236                         .in_cables  = 0x0003
1237                 }
1238         }
1239 },
1240 /* Roland UA-101 in High-Speed Mode only */
1241 {
1242         USB_DEVICE(0x0582, 0x007d),
1243         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1244                 .vendor_name = "Roland",
1245                 .product_name = "UA-101",
1246                 .ifnum = QUIRK_ANY_INTERFACE,
1247                 .type = QUIRK_COMPOSITE,
1248                 .data = (const struct snd_usb_audio_quirk[]) {
1249                         {
1250                                 .ifnum = 0,
1251                                 .type = QUIRK_AUDIO_EDIROL_UA101
1252                         },
1253                         {
1254                                 .ifnum = 1,
1255                                 .type = QUIRK_AUDIO_EDIROL_UA101
1256                         },
1257                         {
1258                                 .ifnum = 2,
1259                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1260                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1261                                         .out_cables = 0x0001,
1262                                         .in_cables  = 0x0001
1263                                 }
1264                         },
1265                         {
1266                                 .ifnum = -1
1267                         }
1268                 }
1269         }
1270 },
1271 {
1272         /* has ID 0x0081 when not in "Advanced Driver" mode */
1273         USB_DEVICE(0x0582, 0x0080),
1274         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1275                 .vendor_name = "Roland",
1276                 .product_name = "G-70",
1277                 .ifnum = 0,
1278                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1279                 .data = & (const struct snd_usb_midi_endpoint_info) {
1280                         .out_cables = 0x0001,
1281                         .in_cables  = 0x0001
1282                 }
1283         }
1284 },
1285         /* TODO: add Roland V-SYNTH XT support */
1286         /* TODO: add BOSS GT-PRO support */
1287 {
1288         /* has ID 0x008c when not in "Advanced Driver" mode */
1289         USB_DEVICE(0x0582, 0x008b),
1290         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1291                 .vendor_name = "EDIROL",
1292                 .product_name = "PC-50",
1293                 .ifnum = 0,
1294                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1295                 .data = & (const struct snd_usb_midi_endpoint_info) {
1296                         .out_cables = 0x0001,
1297                         .in_cables  = 0x0001
1298                 }
1299         }
1300 },
1301         /* TODO: add Edirol PC-80 support */
1302 {
1303         USB_DEVICE(0x0582, 0x0096),
1304         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1305                 .vendor_name = "EDIROL",
1306                 .product_name = "UA-1EX",
1307                 .ifnum = QUIRK_ANY_INTERFACE,
1308                 .type = QUIRK_COMPOSITE,
1309                 .data = (const struct snd_usb_audio_quirk[]) {
1310                         {
1311                                 .ifnum = 0,
1312                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1313                         },
1314                         {
1315                                 .ifnum = 1,
1316                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1317                         },
1318                         {
1319                                 .ifnum = -1
1320                         }
1321                 }
1322         }
1323 },
1324 {
1325         USB_DEVICE(0x0582, 0x009a),
1326         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1327                 .vendor_name = "EDIROL",
1328                 .product_name = "UM-3EX",
1329                 .ifnum = 0,
1330                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1331                 .data = & (const struct snd_usb_midi_endpoint_info) {
1332                         .out_cables = 0x000f,
1333                         .in_cables  = 0x000f
1334                 }
1335         }
1336 },
1337         /* TODO: add Edirol MD-P1 support */
1338 {
1339         /* Roland SH-201 */
1340         USB_DEVICE(0x0582, 0x00ad),
1341         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1342                 .vendor_name = "Roland",
1343                 .product_name = "SH-201",
1344                 .ifnum = QUIRK_ANY_INTERFACE,
1345                 .type = QUIRK_COMPOSITE,
1346                 .data = (const struct snd_usb_audio_quirk[]) {
1347                         {
1348                                 .ifnum = 0,
1349                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1350                         },
1351                         {
1352                                 .ifnum = 1,
1353                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1354                         },
1355                         {
1356                                 .ifnum = 2,
1357                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1358                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1359                                         .out_cables = 0x0001,
1360                                         .in_cables  = 0x0001
1361                                 }
1362                         },
1363                         {
1364                                 .ifnum = -1
1365                         }
1366                 }
1367         }
1368 },
1369
1370 /* Guillemot devices */
1371 {
1372         /*
1373          * This is for the "Windows Edition" where the external MIDI ports are
1374          * the only MIDI ports; the control data is reported through HID
1375          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1376          * compliant USB MIDI ports for external MIDI and controls.
1377          */
1378         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1379         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1380                 .vendor_name = "Hercules",
1381                 .product_name = "DJ Console (WE)",
1382                 .ifnum = 4,
1383                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1384                 .data = & (const struct snd_usb_midi_endpoint_info) {
1385                         .out_cables = 0x0001,
1386                         .in_cables = 0x0001
1387                 }
1388         }
1389 },
1390
1391 /* Midiman/M-Audio devices */
1392 {
1393         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1394         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1395                 .vendor_name = "M-Audio",
1396                 .product_name = "MidiSport 2x2",
1397                 .ifnum = QUIRK_ANY_INTERFACE,
1398                 .type = QUIRK_MIDI_MIDIMAN,
1399                 .data = & (const struct snd_usb_midi_endpoint_info) {
1400                         .out_cables = 0x0003,
1401                         .in_cables  = 0x0003
1402                 }
1403         }
1404 },
1405 {
1406         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1407         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1408                 .vendor_name = "M-Audio",
1409                 .product_name = "MidiSport 1x1",
1410                 .ifnum = QUIRK_ANY_INTERFACE,
1411                 .type = QUIRK_MIDI_MIDIMAN,
1412                 .data = & (const struct snd_usb_midi_endpoint_info) {
1413                         .out_cables = 0x0001,
1414                         .in_cables  = 0x0001
1415                 }
1416         }
1417 },
1418 {
1419         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1420         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1421                 .vendor_name = "M-Audio",
1422                 .product_name = "Keystation",
1423                 .ifnum = QUIRK_ANY_INTERFACE,
1424                 .type = QUIRK_MIDI_MIDIMAN,
1425                 .data = & (const struct snd_usb_midi_endpoint_info) {
1426                         .out_cables = 0x0001,
1427                         .in_cables  = 0x0001
1428                 }
1429         }
1430 },
1431 {
1432         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1433         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1434                 .vendor_name = "M-Audio",
1435                 .product_name = "MidiSport 4x4",
1436                 .ifnum = QUIRK_ANY_INTERFACE,
1437                 .type = QUIRK_MIDI_MIDIMAN,
1438                 .data = & (const struct snd_usb_midi_endpoint_info) {
1439                         .out_cables = 0x000f,
1440                         .in_cables  = 0x000f
1441                 }
1442         }
1443 },
1444 {
1445         /*
1446          * For hardware revision 1.05; in the later revisions (1.10 and
1447          * 1.21), 0x1031 is the ID for the device without firmware.
1448          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1449          */
1450         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1451         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1452                 .vendor_name = "M-Audio",
1453                 .product_name = "MidiSport 8x8",
1454                 .ifnum = QUIRK_ANY_INTERFACE,
1455                 .type = QUIRK_MIDI_MIDIMAN,
1456                 .data = & (const struct snd_usb_midi_endpoint_info) {
1457                         .out_cables = 0x01ff,
1458                         .in_cables  = 0x01ff
1459                 }
1460         }
1461 },
1462 {
1463         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1464         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1465                 .vendor_name = "M-Audio",
1466                 .product_name = "MidiSport 8x8",
1467                 .ifnum = QUIRK_ANY_INTERFACE,
1468                 .type = QUIRK_MIDI_MIDIMAN,
1469                 .data = & (const struct snd_usb_midi_endpoint_info) {
1470                         .out_cables = 0x01ff,
1471                         .in_cables  = 0x01ff
1472                 }
1473         }
1474 },
1475 {
1476         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1477         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1478                 .vendor_name = "M-Audio",
1479                 .product_name = "MidiSport 2x4",
1480                 .ifnum = QUIRK_ANY_INTERFACE,
1481                 .type = QUIRK_MIDI_MIDIMAN,
1482                 .data = & (const struct snd_usb_midi_endpoint_info) {
1483                         .out_cables = 0x000f,
1484                         .in_cables  = 0x0003
1485                 }
1486         }
1487 },
1488 {
1489         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1490         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1491                 .vendor_name = "M-Audio",
1492                 .product_name = "Quattro",
1493                 .ifnum = QUIRK_ANY_INTERFACE,
1494                 .type = QUIRK_COMPOSITE,
1495                 .data = & (const struct snd_usb_audio_quirk[]) {
1496                         /*
1497                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1498                          * and share endpoints with the other interfaces.
1499                          * Ignore them.  The other interfaces can do 24 bits,
1500                          * but captured samples are big-endian (see usbaudio.c).
1501                          */
1502                         {
1503                                 .ifnum = 0,
1504                                 .type = QUIRK_IGNORE_INTERFACE
1505                         },
1506                         {
1507                                 .ifnum = 1,
1508                                 .type = QUIRK_IGNORE_INTERFACE
1509                         },
1510                         {
1511                                 .ifnum = 2,
1512                                 .type = QUIRK_IGNORE_INTERFACE
1513                         },
1514                         {
1515                                 .ifnum = 3,
1516                                 .type = QUIRK_IGNORE_INTERFACE
1517                         },
1518                         {
1519                                 .ifnum = 4,
1520                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1521                         },
1522                         {
1523                                 .ifnum = 5,
1524                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1525                         },
1526                         {
1527                                 .ifnum = 6,
1528                                 .type = QUIRK_IGNORE_INTERFACE
1529                         },
1530                         {
1531                                 .ifnum = 7,
1532                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1533                         },
1534                         {
1535                                 .ifnum = 8,
1536                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1537                         },
1538                         {
1539                                 .ifnum = 9,
1540                                 .type = QUIRK_MIDI_MIDIMAN,
1541                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1542                                         .out_cables = 0x0001,
1543                                         .in_cables  = 0x0001
1544                                 }
1545                         },
1546                         {
1547                                 .ifnum = -1
1548                         }
1549                 }
1550         }
1551 },
1552 {
1553         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1554         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1555                 .vendor_name = "M-Audio",
1556                 .product_name = "AudioPhile",
1557                 .ifnum = 6,
1558                 .type = QUIRK_MIDI_MIDIMAN,
1559                 .data = & (const struct snd_usb_midi_endpoint_info) {
1560                         .out_cables = 0x0001,
1561                         .in_cables  = 0x0001
1562                 }
1563         }
1564 },
1565 {
1566         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1567         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1568                 .vendor_name = "M-Audio",
1569                 .product_name = "Ozone",
1570                 .ifnum = 3,
1571                 .type = QUIRK_MIDI_MIDIMAN,
1572                 .data = & (const struct snd_usb_midi_endpoint_info) {
1573                         .out_cables = 0x0001,
1574                         .in_cables  = 0x0001
1575                 }
1576         }
1577 },
1578 {
1579         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1580         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1581                 .vendor_name = "M-Audio",
1582                 .product_name = "OmniStudio",
1583                 .ifnum = QUIRK_ANY_INTERFACE,
1584                 .type = QUIRK_COMPOSITE,
1585                 .data = & (const struct snd_usb_audio_quirk[]) {
1586                         {
1587                                 .ifnum = 0,
1588                                 .type = QUIRK_IGNORE_INTERFACE
1589                         },
1590                         {
1591                                 .ifnum = 1,
1592                                 .type = QUIRK_IGNORE_INTERFACE
1593                         },
1594                         {
1595                                 .ifnum = 2,
1596                                 .type = QUIRK_IGNORE_INTERFACE
1597                         },
1598                         {
1599                                 .ifnum = 3,
1600                                 .type = QUIRK_IGNORE_INTERFACE
1601                         },
1602                         {
1603                                 .ifnum = 4,
1604                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1605                         },
1606                         {
1607                                 .ifnum = 5,
1608                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1609                         },
1610                         {
1611                                 .ifnum = 6,
1612                                 .type = QUIRK_IGNORE_INTERFACE
1613                         },
1614                         {
1615                                 .ifnum = 7,
1616                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1617                         },
1618                         {
1619                                 .ifnum = 8,
1620                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1621                         },
1622                         {
1623                                 .ifnum = 9,
1624                                 .type = QUIRK_MIDI_MIDIMAN,
1625                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1626                                         .out_cables = 0x0001,
1627                                         .in_cables  = 0x0001
1628                                 }
1629                         },
1630                         {
1631                                 .ifnum = -1
1632                         }
1633                 }
1634         }
1635 },
1636 {
1637         USB_DEVICE(0x0763, 0x2019),
1638         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1639                 /* .vendor_name = "M-Audio", */
1640                 /* .product_name = "Ozone Academic", */
1641                 .ifnum = QUIRK_ANY_INTERFACE,
1642                 .type = QUIRK_COMPOSITE,
1643                 .data = & (const struct snd_usb_audio_quirk[]) {
1644                         {
1645                                 .ifnum = 0,
1646                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1647                         },
1648                         {
1649                                 .ifnum = 1,
1650                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1651                         },
1652                         {
1653                                 .ifnum = 2,
1654                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1655                         },
1656                         {
1657                                 .ifnum = 3,
1658                                 .type = QUIRK_MIDI_MIDIMAN,
1659                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1660                                         .out_cables = 0x0001,
1661                                         .in_cables  = 0x0001
1662                                 }
1663                         },
1664                         {
1665                                 .ifnum = -1
1666                         }
1667                 }
1668         }
1669 },
1670
1671 /* Casio devices */
1672 {
1673         USB_DEVICE(0x07cf, 0x6801),
1674         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1675                 .vendor_name = "Casio",
1676                 .product_name = "PL-40R",
1677                 .ifnum = 0,
1678                 .type = QUIRK_MIDI_YAMAHA
1679         }
1680 },
1681 {
1682         /* this ID is used by several devices without a product ID */
1683         USB_DEVICE(0x07cf, 0x6802),
1684         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1685                 .vendor_name = "Casio",
1686                 .product_name = "Keyboard",
1687                 .ifnum = 0,
1688                 .type = QUIRK_MIDI_YAMAHA
1689         }
1690 },
1691
1692 /* Mark of the Unicorn devices */
1693 {
1694         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1695         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1696                        USB_DEVICE_ID_MATCH_PRODUCT |
1697                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1698         .idVendor = 0x07fd,
1699         .idProduct = 0x0001,
1700         .bDeviceSubClass = 2,
1701         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1702                 .vendor_name = "MOTU",
1703                 .product_name = "Fastlane",
1704                 .ifnum = QUIRK_ANY_INTERFACE,
1705                 .type = QUIRK_COMPOSITE,
1706                 .data = & (const struct snd_usb_audio_quirk[]) {
1707                         {
1708                                 .ifnum = 0,
1709                                 .type = QUIRK_MIDI_RAW
1710                         },
1711                         {
1712                                 .ifnum = 1,
1713                                 .type = QUIRK_IGNORE_INTERFACE
1714                         },
1715                         {
1716                                 .ifnum = -1
1717                         }
1718                 }
1719         }
1720 },
1721
1722 {
1723         /* Creative Sound Blaster MP3+ */
1724         USB_DEVICE(0x041e, 0x3010),
1725         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1726                 .vendor_name = "Creative Labs",
1727                 .product_name = "Sound Blaster MP3+",
1728                 .ifnum = QUIRK_NO_INTERFACE
1729         }
1730
1731 },
1732
1733 /* Emagic devices */
1734 {
1735         USB_DEVICE(0x086a, 0x0001),
1736         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1737                 .vendor_name = "Emagic",
1738                 /* .product_name = "Unitor8", */
1739                 .ifnum = 2,
1740                 .type = QUIRK_MIDI_EMAGIC,
1741                 .data = & (const struct snd_usb_midi_endpoint_info) {
1742                         .out_cables = 0x80ff,
1743                         .in_cables  = 0x80ff
1744                 }
1745         }
1746 },
1747 {
1748         USB_DEVICE(0x086a, 0x0002),
1749         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1750                 .vendor_name = "Emagic",
1751                 /* .product_name = "AMT8", */
1752                 .ifnum = 2,
1753                 .type = QUIRK_MIDI_EMAGIC,
1754                 .data = & (const struct snd_usb_midi_endpoint_info) {
1755                         .out_cables = 0x80ff,
1756                         .in_cables  = 0x80ff
1757                 }
1758         }
1759 },
1760 {
1761         USB_DEVICE(0x086a, 0x0003),
1762         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1763                 .vendor_name = "Emagic",
1764                 /* .product_name = "MT4", */
1765                 .ifnum = 2,
1766                 .type = QUIRK_MIDI_EMAGIC,
1767                 .data = & (const struct snd_usb_midi_endpoint_info) {
1768                         .out_cables = 0x800f,
1769                         .in_cables  = 0x8003
1770                 }
1771         }
1772 },
1773
1774 /* TerraTec devices */
1775 {
1776         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1777         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1778                 .vendor_name = "TerraTec",
1779                 .product_name = "PHASE 26",
1780                 .ifnum = 3,
1781                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1782         }
1783 },
1784 {
1785         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1786         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1787                 .vendor_name = "TerraTec",
1788                 .product_name = "PHASE 26",
1789                 .ifnum = 3,
1790                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1791         }
1792 },
1793 {
1794         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1795         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1796                 .vendor_name = "TerraTec",
1797                 .product_name = "PHASE 26",
1798                 .ifnum = 3,
1799                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1800         }
1801 },
1802 {
1803         USB_DEVICE(0x0ccd, 0x0035),
1804         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1805                 .vendor_name = "Miditech",
1806                 .product_name = "Play'n Roll",
1807                 .ifnum = 0,
1808                 .type = QUIRK_MIDI_CME
1809         }
1810 },
1811
1812 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
1813 {
1814         USB_DEVICE(0x103d, 0x0100),
1815                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1816                 .vendor_name = "Stanton",
1817                 .product_name = "ScratchAmp",
1818                 .ifnum = QUIRK_NO_INTERFACE
1819         }
1820 },
1821 {
1822         USB_DEVICE(0x103d, 0x0101),
1823                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1824                 .vendor_name = "Stanton",
1825                 .product_name = "ScratchAmp",
1826                 .ifnum = QUIRK_NO_INTERFACE
1827         }
1828 },
1829
1830 /* Novation EMS devices */
1831 {
1832         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1833         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1834                 .vendor_name = "Novation",
1835                 .product_name = "ReMOTE Audio/XStation",
1836                 .ifnum = 4,
1837                 .type = QUIRK_MIDI_NOVATION
1838         }
1839 },
1840 {
1841         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1842         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1843                 .vendor_name = "Novation",
1844                 .product_name = "Speedio",
1845                 .ifnum = 3,
1846                 .type = QUIRK_MIDI_NOVATION
1847         }
1848 },
1849 {
1850         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1851         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1852                 .vendor_name = "Novation",
1853                 .product_name = "ReMOTE25",
1854                 .ifnum = 0,
1855                 .type = QUIRK_MIDI_NOVATION
1856         }
1857 },
1858
1859 /* */
1860 {
1861         /* aka. Serato Scratch Live DJ Box */
1862         USB_DEVICE(0x13e5, 0x0001),
1863         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1864                 .vendor_name = "Rane",
1865                 .product_name = "SL-1",
1866                 .ifnum = QUIRK_NO_INTERFACE
1867         }
1868 },
1869
1870 /* Miditech devices */
1871 {
1872         USB_DEVICE(0x4752, 0x0011),
1873         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1874                 .vendor_name = "Miditech",
1875                 .product_name = "Midistart-2",
1876                 .ifnum = 0,
1877                 .type = QUIRK_MIDI_CME
1878         }
1879 },
1880
1881 /* Central Music devices */
1882 {
1883         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1884         USB_DEVICE(0x7104, 0x2202),
1885         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1886                 .ifnum = 0,
1887                 .type = QUIRK_MIDI_CME
1888         }
1889 },
1890
1891 {
1892         /*
1893          * Some USB MIDI devices don't have an audio control interface,
1894          * so we have to grab MIDI streaming interfaces here.
1895          */
1896         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1897                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1898         .bInterfaceClass = USB_CLASS_AUDIO,
1899         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1900         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1901                 .ifnum = QUIRK_ANY_INTERFACE,
1902                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1903         }
1904 },
1905
1906 #undef USB_DEVICE_VENDOR_SPEC