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