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