SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 {
1383         /* Roland SonicCell */
1384         USB_DEVICE(0x0582, 0x00c2),
1385         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1386                 .vendor_name = "Roland",
1387                 .product_name = "SonicCell",
1388                 .ifnum = QUIRK_ANY_INTERFACE,
1389                 .type = QUIRK_COMPOSITE,
1390                 .data = (const struct snd_usb_audio_quirk[]) {
1391                         {
1392                                 .ifnum = 0,
1393                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1394                         },
1395                         {
1396                                 .ifnum = 1,
1397                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1398                         },
1399                         {
1400                                 .ifnum = 2,
1401                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1402                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1403                                         .out_cables = 0x0001,
1404                                         .in_cables  = 0x0001
1405                                 }
1406                         },
1407                         {
1408                                 .ifnum = -1
1409                         }
1410                 }
1411         }
1412 },
1413
1414
1415 /* Guillemot devices */
1416 {
1417         /*
1418          * This is for the "Windows Edition" where the external MIDI ports are
1419          * the only MIDI ports; the control data is reported through HID
1420          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1421          * compliant USB MIDI ports for external MIDI and controls.
1422          */
1423         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1424         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1425                 .vendor_name = "Hercules",
1426                 .product_name = "DJ Console (WE)",
1427                 .ifnum = 4,
1428                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1429                 .data = & (const struct snd_usb_midi_endpoint_info) {
1430                         .out_cables = 0x0001,
1431                         .in_cables = 0x0001
1432                 }
1433         }
1434 },
1435
1436 /* Midiman/M-Audio devices */
1437 {
1438         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1439         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1440                 .vendor_name = "M-Audio",
1441                 .product_name = "MidiSport 2x2",
1442                 .ifnum = QUIRK_ANY_INTERFACE,
1443                 .type = QUIRK_MIDI_MIDIMAN,
1444                 .data = & (const struct snd_usb_midi_endpoint_info) {
1445                         .out_cables = 0x0003,
1446                         .in_cables  = 0x0003
1447                 }
1448         }
1449 },
1450 {
1451         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1452         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1453                 .vendor_name = "M-Audio",
1454                 .product_name = "MidiSport 1x1",
1455                 .ifnum = QUIRK_ANY_INTERFACE,
1456                 .type = QUIRK_MIDI_MIDIMAN,
1457                 .data = & (const struct snd_usb_midi_endpoint_info) {
1458                         .out_cables = 0x0001,
1459                         .in_cables  = 0x0001
1460                 }
1461         }
1462 },
1463 {
1464         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1465         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1466                 .vendor_name = "M-Audio",
1467                 .product_name = "Keystation",
1468                 .ifnum = QUIRK_ANY_INTERFACE,
1469                 .type = QUIRK_MIDI_MIDIMAN,
1470                 .data = & (const struct snd_usb_midi_endpoint_info) {
1471                         .out_cables = 0x0001,
1472                         .in_cables  = 0x0001
1473                 }
1474         }
1475 },
1476 {
1477         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1478         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1479                 .vendor_name = "M-Audio",
1480                 .product_name = "MidiSport 4x4",
1481                 .ifnum = QUIRK_ANY_INTERFACE,
1482                 .type = QUIRK_MIDI_MIDIMAN,
1483                 .data = & (const struct snd_usb_midi_endpoint_info) {
1484                         .out_cables = 0x000f,
1485                         .in_cables  = 0x000f
1486                 }
1487         }
1488 },
1489 {
1490         /*
1491          * For hardware revision 1.05; in the later revisions (1.10 and
1492          * 1.21), 0x1031 is the ID for the device without firmware.
1493          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1494          */
1495         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1496         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1497                 .vendor_name = "M-Audio",
1498                 .product_name = "MidiSport 8x8",
1499                 .ifnum = QUIRK_ANY_INTERFACE,
1500                 .type = QUIRK_MIDI_MIDIMAN,
1501                 .data = & (const struct snd_usb_midi_endpoint_info) {
1502                         .out_cables = 0x01ff,
1503                         .in_cables  = 0x01ff
1504                 }
1505         }
1506 },
1507 {
1508         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1509         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1510                 .vendor_name = "M-Audio",
1511                 .product_name = "MidiSport 8x8",
1512                 .ifnum = QUIRK_ANY_INTERFACE,
1513                 .type = QUIRK_MIDI_MIDIMAN,
1514                 .data = & (const struct snd_usb_midi_endpoint_info) {
1515                         .out_cables = 0x01ff,
1516                         .in_cables  = 0x01ff
1517                 }
1518         }
1519 },
1520 {
1521         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1522         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1523                 .vendor_name = "M-Audio",
1524                 .product_name = "MidiSport 2x4",
1525                 .ifnum = QUIRK_ANY_INTERFACE,
1526                 .type = QUIRK_MIDI_MIDIMAN,
1527                 .data = & (const struct snd_usb_midi_endpoint_info) {
1528                         .out_cables = 0x000f,
1529                         .in_cables  = 0x0003
1530                 }
1531         }
1532 },
1533 {
1534         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1535         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1536                 .vendor_name = "M-Audio",
1537                 .product_name = "Quattro",
1538                 .ifnum = QUIRK_ANY_INTERFACE,
1539                 .type = QUIRK_COMPOSITE,
1540                 .data = & (const struct snd_usb_audio_quirk[]) {
1541                         /*
1542                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1543                          * and share endpoints with the other interfaces.
1544                          * Ignore them.  The other interfaces can do 24 bits,
1545                          * but captured samples are big-endian (see usbaudio.c).
1546                          */
1547                         {
1548                                 .ifnum = 0,
1549                                 .type = QUIRK_IGNORE_INTERFACE
1550                         },
1551                         {
1552                                 .ifnum = 1,
1553                                 .type = QUIRK_IGNORE_INTERFACE
1554                         },
1555                         {
1556                                 .ifnum = 2,
1557                                 .type = QUIRK_IGNORE_INTERFACE
1558                         },
1559                         {
1560                                 .ifnum = 3,
1561                                 .type = QUIRK_IGNORE_INTERFACE
1562                         },
1563                         {
1564                                 .ifnum = 4,
1565                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1566                         },
1567                         {
1568                                 .ifnum = 5,
1569                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1570                         },
1571                         {
1572                                 .ifnum = 6,
1573                                 .type = QUIRK_IGNORE_INTERFACE
1574                         },
1575                         {
1576                                 .ifnum = 7,
1577                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1578                         },
1579                         {
1580                                 .ifnum = 8,
1581                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1582                         },
1583                         {
1584                                 .ifnum = 9,
1585                                 .type = QUIRK_MIDI_MIDIMAN,
1586                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1587                                         .out_cables = 0x0001,
1588                                         .in_cables  = 0x0001
1589                                 }
1590                         },
1591                         {
1592                                 .ifnum = -1
1593                         }
1594                 }
1595         }
1596 },
1597 {
1598         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1599         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1600                 .vendor_name = "M-Audio",
1601                 .product_name = "AudioPhile",
1602                 .ifnum = 6,
1603                 .type = QUIRK_MIDI_MIDIMAN,
1604                 .data = & (const struct snd_usb_midi_endpoint_info) {
1605                         .out_cables = 0x0001,
1606                         .in_cables  = 0x0001
1607                 }
1608         }
1609 },
1610 {
1611         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1612         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1613                 .vendor_name = "M-Audio",
1614                 .product_name = "Ozone",
1615                 .ifnum = 3,
1616                 .type = QUIRK_MIDI_MIDIMAN,
1617                 .data = & (const struct snd_usb_midi_endpoint_info) {
1618                         .out_cables = 0x0001,
1619                         .in_cables  = 0x0001
1620                 }
1621         }
1622 },
1623 {
1624         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1625         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1626                 .vendor_name = "M-Audio",
1627                 .product_name = "OmniStudio",
1628                 .ifnum = QUIRK_ANY_INTERFACE,
1629                 .type = QUIRK_COMPOSITE,
1630                 .data = & (const struct snd_usb_audio_quirk[]) {
1631                         {
1632                                 .ifnum = 0,
1633                                 .type = QUIRK_IGNORE_INTERFACE
1634                         },
1635                         {
1636                                 .ifnum = 1,
1637                                 .type = QUIRK_IGNORE_INTERFACE
1638                         },
1639                         {
1640                                 .ifnum = 2,
1641                                 .type = QUIRK_IGNORE_INTERFACE
1642                         },
1643                         {
1644                                 .ifnum = 3,
1645                                 .type = QUIRK_IGNORE_INTERFACE
1646                         },
1647                         {
1648                                 .ifnum = 4,
1649                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1650                         },
1651                         {
1652                                 .ifnum = 5,
1653                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1654                         },
1655                         {
1656                                 .ifnum = 6,
1657                                 .type = QUIRK_IGNORE_INTERFACE
1658                         },
1659                         {
1660                                 .ifnum = 7,
1661                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1662                         },
1663                         {
1664                                 .ifnum = 8,
1665                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1666                         },
1667                         {
1668                                 .ifnum = 9,
1669                                 .type = QUIRK_MIDI_MIDIMAN,
1670                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1671                                         .out_cables = 0x0001,
1672                                         .in_cables  = 0x0001
1673                                 }
1674                         },
1675                         {
1676                                 .ifnum = -1
1677                         }
1678                 }
1679         }
1680 },
1681 {
1682         USB_DEVICE(0x0763, 0x2019),
1683         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1684                 /* .vendor_name = "M-Audio", */
1685                 /* .product_name = "Ozone Academic", */
1686                 .ifnum = QUIRK_ANY_INTERFACE,
1687                 .type = QUIRK_COMPOSITE,
1688                 .data = & (const struct snd_usb_audio_quirk[]) {
1689                         {
1690                                 .ifnum = 0,
1691                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1692                         },
1693                         {
1694                                 .ifnum = 1,
1695                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1696                         },
1697                         {
1698                                 .ifnum = 2,
1699                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1700                         },
1701                         {
1702                                 .ifnum = 3,
1703                                 .type = QUIRK_MIDI_MIDIMAN,
1704                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1705                                         .out_cables = 0x0001,
1706                                         .in_cables  = 0x0001
1707                                 }
1708                         },
1709                         {
1710                                 .ifnum = -1
1711                         }
1712                 }
1713         }
1714 },
1715
1716 /* Casio devices */
1717 {
1718         USB_DEVICE(0x07cf, 0x6801),
1719         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1720                 .vendor_name = "Casio",
1721                 .product_name = "PL-40R",
1722                 .ifnum = 0,
1723                 .type = QUIRK_MIDI_YAMAHA
1724         }
1725 },
1726 {
1727         /* this ID is used by several devices without a product ID */
1728         USB_DEVICE(0x07cf, 0x6802),
1729         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1730                 .vendor_name = "Casio",
1731                 .product_name = "Keyboard",
1732                 .ifnum = 0,
1733                 .type = QUIRK_MIDI_YAMAHA
1734         }
1735 },
1736
1737 /* Mark of the Unicorn devices */
1738 {
1739         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1740         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1741                        USB_DEVICE_ID_MATCH_PRODUCT |
1742                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1743         .idVendor = 0x07fd,
1744         .idProduct = 0x0001,
1745         .bDeviceSubClass = 2,
1746         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1747                 .vendor_name = "MOTU",
1748                 .product_name = "Fastlane",
1749                 .ifnum = QUIRK_ANY_INTERFACE,
1750                 .type = QUIRK_COMPOSITE,
1751                 .data = & (const struct snd_usb_audio_quirk[]) {
1752                         {
1753                                 .ifnum = 0,
1754                                 .type = QUIRK_MIDI_RAW
1755                         },
1756                         {
1757                                 .ifnum = 1,
1758                                 .type = QUIRK_IGNORE_INTERFACE
1759                         },
1760                         {
1761                                 .ifnum = -1
1762                         }
1763                 }
1764         }
1765 },
1766
1767 /* Emagic devices */
1768 {
1769         USB_DEVICE(0x086a, 0x0001),
1770         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1771                 .vendor_name = "Emagic",
1772                 /* .product_name = "Unitor8", */
1773                 .ifnum = 2,
1774                 .type = QUIRK_MIDI_EMAGIC,
1775                 .data = & (const struct snd_usb_midi_endpoint_info) {
1776                         .out_cables = 0x80ff,
1777                         .in_cables  = 0x80ff
1778                 }
1779         }
1780 },
1781 {
1782         USB_DEVICE(0x086a, 0x0002),
1783         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1784                 .vendor_name = "Emagic",
1785                 /* .product_name = "AMT8", */
1786                 .ifnum = 2,
1787                 .type = QUIRK_MIDI_EMAGIC,
1788                 .data = & (const struct snd_usb_midi_endpoint_info) {
1789                         .out_cables = 0x80ff,
1790                         .in_cables  = 0x80ff
1791                 }
1792         }
1793 },
1794 {
1795         USB_DEVICE(0x086a, 0x0003),
1796         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1797                 .vendor_name = "Emagic",
1798                 /* .product_name = "MT4", */
1799                 .ifnum = 2,
1800                 .type = QUIRK_MIDI_EMAGIC,
1801                 .data = & (const struct snd_usb_midi_endpoint_info) {
1802                         .out_cables = 0x800f,
1803                         .in_cables  = 0x8003
1804                 }
1805         }
1806 },
1807
1808 /* TerraTec devices */
1809 {
1810         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1811         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1812                 .vendor_name = "TerraTec",
1813                 .product_name = "PHASE 26",
1814                 .ifnum = 3,
1815                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1816         }
1817 },
1818 {
1819         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1820         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1821                 .vendor_name = "TerraTec",
1822                 .product_name = "PHASE 26",
1823                 .ifnum = 3,
1824                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1825         }
1826 },
1827 {
1828         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1829         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1830                 .vendor_name = "TerraTec",
1831                 .product_name = "PHASE 26",
1832                 .ifnum = 3,
1833                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1834         }
1835 },
1836 {
1837         USB_DEVICE(0x0ccd, 0x0035),
1838         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1839                 .vendor_name = "Miditech",
1840                 .product_name = "Play'n Roll",
1841                 .ifnum = 0,
1842                 .type = QUIRK_MIDI_CME
1843         }
1844 },
1845
1846 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
1847 {
1848         USB_DEVICE(0x103d, 0x0100),
1849                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1850                 .vendor_name = "Stanton",
1851                 .product_name = "ScratchAmp",
1852                 .ifnum = QUIRK_NO_INTERFACE
1853         }
1854 },
1855 {
1856         USB_DEVICE(0x103d, 0x0101),
1857                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1858                 .vendor_name = "Stanton",
1859                 .product_name = "ScratchAmp",
1860                 .ifnum = QUIRK_NO_INTERFACE
1861         }
1862 },
1863
1864 /* Novation EMS devices */
1865 {
1866         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1867         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1868                 .vendor_name = "Novation",
1869                 .product_name = "ReMOTE Audio/XStation",
1870                 .ifnum = 4,
1871                 .type = QUIRK_MIDI_NOVATION
1872         }
1873 },
1874 {
1875         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1876         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1877                 .vendor_name = "Novation",
1878                 .product_name = "Speedio",
1879                 .ifnum = 3,
1880                 .type = QUIRK_MIDI_NOVATION
1881         }
1882 },
1883 {
1884         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1885         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1886                 .vendor_name = "Novation",
1887                 .product_name = "ReMOTE25",
1888                 .ifnum = 0,
1889                 .type = QUIRK_MIDI_NOVATION
1890         }
1891 },
1892
1893 /* */
1894 {
1895         /* aka. Serato Scratch Live DJ Box */
1896         USB_DEVICE(0x13e5, 0x0001),
1897         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1898                 .vendor_name = "Rane",
1899                 .product_name = "SL-1",
1900                 .ifnum = QUIRK_NO_INTERFACE
1901         }
1902 },
1903
1904 /* Miditech devices */
1905 {
1906         USB_DEVICE(0x4752, 0x0011),
1907         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1908                 .vendor_name = "Miditech",
1909                 .product_name = "Midistart-2",
1910                 .ifnum = 0,
1911                 .type = QUIRK_MIDI_CME
1912         }
1913 },
1914
1915 /* Central Music devices */
1916 {
1917         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1918         USB_DEVICE(0x7104, 0x2202),
1919         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1920                 .ifnum = 0,
1921                 .type = QUIRK_MIDI_CME
1922         }
1923 },
1924
1925 {
1926         /*
1927          * Some USB MIDI devices don't have an audio control interface,
1928          * so we have to grab MIDI streaming interfaces here.
1929          */
1930         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1931                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1932         .bInterfaceClass = USB_CLASS_AUDIO,
1933         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1934         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1935                 .ifnum = QUIRK_ANY_INTERFACE,
1936                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1937         }
1938 },
1939
1940 #undef USB_DEVICE_VENDOR_SPEC