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