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