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