sound/usb/quirks-table.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 /* FTDI devices */
  43 {
  44         USB_DEVICE(0x0403, 0xb8d8),
  45         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  46                 /* .vendor_name = "STARR LABS", */
  47                 /* .product_name = "Starr Labs MIDI USB device", */
  48                 .ifnum = 0,
  49                 .type = QUIRK_MIDI_FTDI
  50         }
  51 },
  52
  53 /* Creative/Toshiba Multimedia Center SB-0500 */
  54 {
  55         USB_DEVICE(0x041e, 0x3048),
  56         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  57                 .vendor_name = "Toshiba",
  58                 .product_name = "SB-0500",
  59                 .ifnum = QUIRK_NO_INTERFACE
  60         }
  61 },
  62
  63 /* Creative/E-Mu devices */
  64 {
  65         USB_DEVICE(0x041e, 0x3010),
  66         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  67                 .vendor_name = "Creative Labs",
  68                 .product_name = "Sound Blaster MP3+",
  69                 .ifnum = QUIRK_NO_INTERFACE
  70         }
  71 },
  72 {
  73         /* E-Mu 0202 USB */
  74         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  75         .idVendor = 0x041e,
  76         .idProduct = 0x3f02,
  77         .bInterfaceClass = USB_CLASS_AUDIO,
  78 },
  79 {
  80         /* E-Mu 0404 USB */
  81         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  82         .idVendor = 0x041e,
  83         .idProduct = 0x3f04,
  84         .bInterfaceClass = USB_CLASS_AUDIO,
  85 },
  86 {
  87         /* E-Mu Tracker Pre */
  88         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  89         .idVendor = 0x041e,
  90         .idProduct = 0x3f0a,
  91         .bInterfaceClass = USB_CLASS_AUDIO,
  92 },
  93 {
  94         /* E-Mu 0204 USB */
  95         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  96         .idVendor = 0x041e,
  97         .idProduct = 0x3f19,
  98         .bInterfaceClass = USB_CLASS_AUDIO,
  99 },
 100
 101 /*
 102  * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
 103  * class matches do not take effect without an explicit ID match.
 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 = 0x0850,
 111         .bInterfaceClass = USB_CLASS_AUDIO,
 112         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 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 = 0x08ae,
 120         .bInterfaceClass = USB_CLASS_AUDIO,
 121         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 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 = 0x08c6,
 129         .bInterfaceClass = USB_CLASS_AUDIO,
 130         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 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 = 0x08f0,
 138         .bInterfaceClass = USB_CLASS_AUDIO,
 139         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 140 },
 141 {
 142         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 143                        USB_DEVICE_ID_MATCH_INT_CLASS |
 144                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 145         .idVendor = 0x046d,
 146         .idProduct = 0x08f5,
 147         .bInterfaceClass = USB_CLASS_AUDIO,
 148         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 149 },
 150 {
 151         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
 152                        USB_DEVICE_ID_MATCH_INT_CLASS |
 153                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
 154         .idVendor = 0x046d,
 155         .idProduct = 0x08f6,
 156         .bInterfaceClass = USB_CLASS_AUDIO,
 157         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
 158 },
 159 {
 160         USB_DEVICE(0x046d, 0x0990),
 161         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 162                 .vendor_name = "Logitech, Inc.",
 163                 .product_name = "QuickCam Pro 9000",
 164                 .ifnum = QUIRK_NO_INTERFACE
 165         }
 166 },
 167
 168 /*
 169  * Yamaha devices
 170  */
 171
 172 #define YAMAHA_DEVICE(id, name) { \
 173         USB_DEVICE(0x0499, id), \
 174         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 175                 .vendor_name = "Yamaha", \
 176                 .product_name = name, \
 177                 .ifnum = QUIRK_ANY_INTERFACE, \
 178                 .type = QUIRK_MIDI_YAMAHA \
 179         } \
 180 }
 181 #define YAMAHA_INTERFACE(id, intf, name) { \
 182         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
 183         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
 184                 .vendor_name = "Yamaha", \
 185                 .product_name = name, \
 186                 .ifnum = intf, \
 187                 .type = QUIRK_MIDI_YAMAHA \
 188         } \
 189 }
 190 YAMAHA_DEVICE(0x1000, "UX256"),
 191 YAMAHA_DEVICE(0x1001, "MU1000"),
 192 YAMAHA_DEVICE(0x1002, "MU2000"),
 193 YAMAHA_DEVICE(0x1003, "MU500"),
 194 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
 195 YAMAHA_DEVICE(0x1005, "MOTIF6"),
 196 YAMAHA_DEVICE(0x1006, "MOTIF7"),
 197 YAMAHA_DEVICE(0x1007, "MOTIF8"),
 198 YAMAHA_DEVICE(0x1008, "UX96"),
 199 YAMAHA_DEVICE(0x1009, "UX16"),
 200 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
 201 YAMAHA_DEVICE(0x100c, "UC-MX"),
 202 YAMAHA_DEVICE(0x100d, "UC-KX"),
 203 YAMAHA_DEVICE(0x100e, "S08"),
 204 YAMAHA_DEVICE(0x100f, "CLP-150"),
 205 YAMAHA_DEVICE(0x1010, "CLP-170"),
 206 YAMAHA_DEVICE(0x1011, "P-250"),
 207 YAMAHA_DEVICE(0x1012, "TYROS"),
 208 YAMAHA_DEVICE(0x1013, "PF-500"),
 209 YAMAHA_DEVICE(0x1014, "S90"),
 210 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
 211 YAMAHA_DEVICE(0x1016, "MDP-5"),
 212 YAMAHA_DEVICE(0x1017, "CVP-204"),
 213 YAMAHA_DEVICE(0x1018, "CVP-206"),
 214 YAMAHA_DEVICE(0x1019, "CVP-208"),
 215 YAMAHA_DEVICE(0x101a, "CVP-210"),
 216 YAMAHA_DEVICE(0x101b, "PSR-1100"),
 217 YAMAHA_DEVICE(0x101c, "PSR-2100"),
 218 YAMAHA_DEVICE(0x101d, "CLP-175"),
 219 YAMAHA_DEVICE(0x101e, "PSR-K1"),
 220 YAMAHA_DEVICE(0x101f, "EZ-J24"),
 221 YAMAHA_DEVICE(0x1020, "EZ-250i"),
 222 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
 223 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
 224 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
 225 YAMAHA_DEVICE(0x1024, "CVP-301"),
 226 YAMAHA_DEVICE(0x1025, "CVP-303"),
 227 YAMAHA_DEVICE(0x1026, "CVP-305"),
 228 YAMAHA_DEVICE(0x1027, "CVP-307"),
 229 YAMAHA_DEVICE(0x1028, "CVP-309"),
 230 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 231 YAMAHA_DEVICE(0x102a, "PSR-1500"),
 232 YAMAHA_DEVICE(0x102b, "PSR-3000"),
 233 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 234 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 235 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 236 YAMAHA_DEVICE(0x1032, "DGX-305"),
 237 YAMAHA_DEVICE(0x1033, "DGX-505"),
 238 YAMAHA_DEVICE(0x1034, NULL),
 239 YAMAHA_DEVICE(0x1035, NULL),
 240 YAMAHA_DEVICE(0x1036, NULL),
 241 YAMAHA_DEVICE(0x1037, NULL),
 242 YAMAHA_DEVICE(0x1038, NULL),
 243 YAMAHA_DEVICE(0x1039, NULL),
 244 YAMAHA_DEVICE(0x103a, NULL),
 245 YAMAHA_DEVICE(0x103b, NULL),
 246 YAMAHA_DEVICE(0x103c, NULL),
 247 YAMAHA_DEVICE(0x103d, NULL),
 248 YAMAHA_DEVICE(0x103e, NULL),
 249 YAMAHA_DEVICE(0x103f, NULL),
 250 YAMAHA_DEVICE(0x1040, NULL),
 251 YAMAHA_DEVICE(0x1041, NULL),
 252 YAMAHA_DEVICE(0x1042, NULL),
 253 YAMAHA_DEVICE(0x1043, NULL),
 254 YAMAHA_DEVICE(0x1044, NULL),
 255 YAMAHA_DEVICE(0x1045, NULL),
 256 YAMAHA_INTERFACE(0x104e, 0, NULL),
 257 YAMAHA_DEVICE(0x104f, NULL),
 258 YAMAHA_DEVICE(0x1050, NULL),
 259 YAMAHA_DEVICE(0x1051, NULL),
 260 YAMAHA_DEVICE(0x1052, NULL),
 261 YAMAHA_INTERFACE(0x1053, 0, NULL),
 262 YAMAHA_INTERFACE(0x1054, 0, NULL),
 263 YAMAHA_DEVICE(0x1055, NULL),
 264 YAMAHA_DEVICE(0x1056, NULL),
 265 YAMAHA_DEVICE(0x1057, NULL),
 266 YAMAHA_DEVICE(0x1058, NULL),
 267 YAMAHA_DEVICE(0x1059, NULL),
 268 YAMAHA_DEVICE(0x105a, NULL),
 269 YAMAHA_DEVICE(0x105b, NULL),
 270 YAMAHA_DEVICE(0x105c, NULL),
 271 YAMAHA_DEVICE(0x105d, NULL),
 272 {
 273         USB_DEVICE(0x0499, 0x1503),
 274         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 275                 /* .vendor_name = "Yamaha", */
 276                 /* .product_name = "MOX6/MOX8", */
 277                 .ifnum = QUIRK_ANY_INTERFACE,
 278                 .type = QUIRK_COMPOSITE,
 279                 .data = (const struct snd_usb_audio_quirk[]) {
 280                         {
 281                                 .ifnum = 1,
 282                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 283                         },
 284                         {
 285                                 .ifnum = 2,
 286                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 287                         },
 288                         {
 289                                 .ifnum = 3,
 290                                 .type = QUIRK_MIDI_YAMAHA
 291                         },
 292                         {
 293                                 .ifnum = -1
 294                         }
 295                 }
 296         }
 297 },
 298 YAMAHA_DEVICE(0x2000, "DGP-7"),
 299 YAMAHA_DEVICE(0x2001, "DGP-5"),
 300 YAMAHA_DEVICE(0x2002, NULL),
 301 YAMAHA_DEVICE(0x2003, NULL),
 302 YAMAHA_DEVICE(0x5000, "CS1D"),
 303 YAMAHA_DEVICE(0x5001, "DSP1D"),
 304 YAMAHA_DEVICE(0x5002, "DME32"),
 305 YAMAHA_DEVICE(0x5003, "DM2000"),
 306 YAMAHA_DEVICE(0x5004, "02R96"),
 307 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 308 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 309 YAMAHA_DEVICE(0x5007, "DM1000"),
 310 YAMAHA_DEVICE(0x5008, "01V96"),
 311 YAMAHA_DEVICE(0x5009, "SPX2000"),
 312 YAMAHA_DEVICE(0x500a, "PM5D"),
 313 YAMAHA_DEVICE(0x500b, "DME64N"),
 314 YAMAHA_DEVICE(0x500c, "DME24N"),
 315 YAMAHA_DEVICE(0x500d, NULL),
 316 YAMAHA_DEVICE(0x500e, NULL),
 317 YAMAHA_DEVICE(0x500f, NULL),
 318 YAMAHA_DEVICE(0x7000, "DTX"),
 319 YAMAHA_DEVICE(0x7010, "UB99"),
 320 #undef YAMAHA_DEVICE
 321 #undef YAMAHA_INTERFACE
 322
 323 /*
 324  * Roland/RolandED/Edirol/BOSS devices
 325  */
 326 {
 327         USB_DEVICE(0x0582, 0x0000),
 328         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 329                 .vendor_name = "Roland",
 330                 .product_name = "UA-100",
 331                 .ifnum = QUIRK_ANY_INTERFACE,
 332                 .type = QUIRK_COMPOSITE,
 333                 .data = (const struct snd_usb_audio_quirk[]) {
 334                         {
 335                                 .ifnum = 0,
 336                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 337                                 .data = & (const struct audioformat) {
 338                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 339                                         .channels = 4,
 340                                         .iface = 0,
 341                                         .altsetting = 1,
 342                                         .altset_idx = 1,
 343                                         .attributes = 0,
 344                                         .endpoint = 0x01,
 345                                         .ep_attr = 0x09,
 346                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 347                                         .rate_min = 44100,
 348                                         .rate_max = 44100,
 349                                 }
 350                         },
 351                         {
 352                                 .ifnum = 1,
 353                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 354                                 .data = & (const struct audioformat) {
 355                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 356                                         .channels = 2,
 357                                         .iface = 1,
 358                                         .altsetting = 1,
 359                                         .altset_idx = 1,
 360                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX,
 361                                         .endpoint = 0x81,
 362                                         .ep_attr = 0x05,
 363                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 364                                         .rate_min = 44100,
 365                                         .rate_max = 44100,
 366                                 }
 367                         },
 368                         {
 369                                 .ifnum = 2,
 370                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 371                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 372                                         .out_cables = 0x0007,
 373                                         .in_cables  = 0x0007
 374                                 }
 375                         },
 376                         {
 377                                 .ifnum = -1
 378                         }
 379                 }
 380         }
 381 },
 382 {
 383         USB_DEVICE(0x0582, 0x0002),
 384         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 385                 .vendor_name = "EDIROL",
 386                 .product_name = "UM-4",
 387                 .ifnum = QUIRK_ANY_INTERFACE,
 388                 .type = QUIRK_COMPOSITE,
 389                 .data = (const struct snd_usb_audio_quirk[]) {
 390                         {
 391                                 .ifnum = 0,
 392                                 .type = QUIRK_IGNORE_INTERFACE
 393                         },
 394                         {
 395                                 .ifnum = 1,
 396                                 .type = QUIRK_IGNORE_INTERFACE
 397                         },
 398                         {
 399                                 .ifnum = 2,
 400                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 401                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 402                                         .out_cables = 0x000f,
 403                                         .in_cables  = 0x000f
 404                                 }
 405                         },
 406                         {
 407                                 .ifnum = -1
 408                         }
 409                 }
 410         }
 411 },
 412 {
 413         USB_DEVICE(0x0582, 0x0003),
 414         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 415                 .vendor_name = "Roland",
 416                 .product_name = "SC-8850",
 417                 .ifnum = QUIRK_ANY_INTERFACE,
 418                 .type = QUIRK_COMPOSITE,
 419                 .data = (const struct snd_usb_audio_quirk[]) {
 420                         {
 421                                 .ifnum = 0,
 422                                 .type = QUIRK_IGNORE_INTERFACE
 423                         },
 424                         {
 425                                 .ifnum = 1,
 426                                 .type = QUIRK_IGNORE_INTERFACE
 427                         },
 428                         {
 429                                 .ifnum = 2,
 430                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 431                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 432                                         .out_cables = 0x003f,
 433                                         .in_cables  = 0x003f
 434                                 }
 435                         },
 436                         {
 437                                 .ifnum = -1
 438                         }
 439                 }
 440         }
 441 },
 442 {
 443         USB_DEVICE(0x0582, 0x0004),
 444         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 445                 .vendor_name = "Roland",
 446                 .product_name = "U-8",
 447                 .ifnum = QUIRK_ANY_INTERFACE,
 448                 .type = QUIRK_COMPOSITE,
 449                 .data = (const struct snd_usb_audio_quirk[]) {
 450                         {
 451                                 .ifnum = 0,
 452                                 .type = QUIRK_IGNORE_INTERFACE
 453                         },
 454                         {
 455                                 .ifnum = 1,
 456                                 .type = QUIRK_IGNORE_INTERFACE
 457                         },
 458                         {
 459                                 .ifnum = 2,
 460                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 461                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 462                                         .out_cables = 0x0005,
 463                                         .in_cables  = 0x0005
 464                                 }
 465                         },
 466                         {
 467                                 .ifnum = -1
 468                         }
 469                 }
 470         }
 471 },
 472 {
 473         /* Has ID 0x0099 when not in "Advanced Driver" mode.
 474          * The UM-2EX has only one input, but we cannot detect this. */
 475         USB_DEVICE(0x0582, 0x0005),
 476         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 477                 .vendor_name = "EDIROL",
 478                 .product_name = "UM-2",
 479                 .ifnum = QUIRK_ANY_INTERFACE,
 480                 .type = QUIRK_COMPOSITE,
 481                 .data = (const struct snd_usb_audio_quirk[]) {
 482                         {
 483                                 .ifnum = 0,
 484                                 .type = QUIRK_IGNORE_INTERFACE
 485                         },
 486                         {
 487                                 .ifnum = 1,
 488                                 .type = QUIRK_IGNORE_INTERFACE
 489                         },
 490                         {
 491                                 .ifnum = 2,
 492                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 493                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 494                                         .out_cables = 0x0003,
 495                                         .in_cables  = 0x0003
 496                                 }
 497                         },
 498                         {
 499                                 .ifnum = -1
 500                         }
 501                 }
 502         }
 503 },
 504 {
 505         USB_DEVICE(0x0582, 0x0007),
 506         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 507                 .vendor_name = "Roland",
 508                 .product_name = "SC-8820",
 509                 .ifnum = QUIRK_ANY_INTERFACE,
 510                 .type = QUIRK_COMPOSITE,
 511                 .data = (const struct snd_usb_audio_quirk[]) {
 512                         {
 513                                 .ifnum = 0,
 514                                 .type = QUIRK_IGNORE_INTERFACE
 515                         },
 516                         {
 517                                 .ifnum = 1,
 518                                 .type = QUIRK_IGNORE_INTERFACE
 519                         },
 520                         {
 521                                 .ifnum = 2,
 522                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 523                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 524                                         .out_cables = 0x0013,
 525                                         .in_cables  = 0x0013
 526                                 }
 527                         },
 528                         {
 529                                 .ifnum = -1
 530                         }
 531                 }
 532         }
 533 },
 534 {
 535         USB_DEVICE(0x0582, 0x0008),
 536         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 537                 .vendor_name = "Roland",
 538                 .product_name = "PC-300",
 539                 .ifnum = QUIRK_ANY_INTERFACE,
 540                 .type = QUIRK_COMPOSITE,
 541                 .data = (const struct snd_usb_audio_quirk[]) {
 542                         {
 543                                 .ifnum = 0,
 544                                 .type = QUIRK_IGNORE_INTERFACE
 545                         },
 546                         {
 547                                 .ifnum = 1,
 548                                 .type = QUIRK_IGNORE_INTERFACE
 549                         },
 550                         {
 551                                 .ifnum = 2,
 552                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 553                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 554                                         .out_cables = 0x0001,
 555                                         .in_cables  = 0x0001
 556                                 }
 557                         },
 558                         {
 559                                 .ifnum = -1
 560                         }
 561                 }
 562         }
 563 },
 564 {
 565         /* has ID 0x009d when not in "Advanced Driver" mode */
 566         USB_DEVICE(0x0582, 0x0009),
 567         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 568                 .vendor_name = "EDIROL",
 569                 .product_name = "UM-1",
 570                 .ifnum = QUIRK_ANY_INTERFACE,
 571                 .type = QUIRK_COMPOSITE,
 572                 .data = (const struct snd_usb_audio_quirk[]) {
 573                         {
 574                                 .ifnum = 0,
 575                                 .type = QUIRK_IGNORE_INTERFACE
 576                         },
 577                         {
 578                                 .ifnum = 1,
 579                                 .type = QUIRK_IGNORE_INTERFACE
 580                         },
 581                         {
 582                                 .ifnum = 2,
 583                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 584                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 585                                         .out_cables = 0x0001,
 586                                         .in_cables  = 0x0001
 587                                 }
 588                         },
 589                         {
 590                                 .ifnum = -1
 591                         }
 592                 }
 593         }
 594 },
 595 {
 596         USB_DEVICE(0x0582, 0x000b),
 597         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 598                 .vendor_name = "Roland",
 599                 .product_name = "SK-500",
 600                 .ifnum = QUIRK_ANY_INTERFACE,
 601                 .type = QUIRK_COMPOSITE,
 602                 .data = (const struct snd_usb_audio_quirk[]) {
 603                         {
 604                                 .ifnum = 0,
 605                                 .type = QUIRK_IGNORE_INTERFACE
 606                         },
 607                         {
 608                                 .ifnum = 1,
 609                                 .type = QUIRK_IGNORE_INTERFACE
 610                         },
 611                         {
 612                                 .ifnum = 2,
 613                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 614                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 615                                         .out_cables = 0x0013,
 616                                         .in_cables  = 0x0013
 617                                 }
 618                         },
 619                         {
 620                                 .ifnum = -1
 621                         }
 622                 }
 623         }
 624 },
 625 {
 626         /* thanks to Emiliano Grilli <emillo@libero.it>
 627          * for helping researching this data */
 628         USB_DEVICE(0x0582, 0x000c),
 629         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 630                 .vendor_name = "Roland",
 631                 .product_name = "SC-D70",
 632                 .ifnum = QUIRK_ANY_INTERFACE,
 633                 .type = QUIRK_COMPOSITE,
 634                 .data = (const struct snd_usb_audio_quirk[]) {
 635                         {
 636                                 .ifnum = 0,
 637                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 638                                 .data = & (const struct audioformat) {
 639                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 640                                         .channels = 2,
 641                                         .iface = 0,
 642                                         .altsetting = 1,
 643                                         .altset_idx = 1,
 644                                         .attributes = 0,
 645                                         .endpoint = 0x01,
 646                                         .ep_attr = 0x01,
 647                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 648                                         .rate_min = 44100,
 649                                         .rate_max = 44100,
 650                                 }
 651                         },
 652                         {
 653                                 .ifnum = 1,
 654                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 655                                 .data = & (const struct audioformat) {
 656                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 657                                         .channels = 2,
 658                                         .iface = 1,
 659                                         .altsetting = 1,
 660                                         .altset_idx = 1,
 661                                         .attributes = 0,
 662                                         .endpoint = 0x81,
 663                                         .ep_attr = 0x01,
 664                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 665                                         .rate_min = 44100,
 666                                         .rate_max = 44100,
 667                                 }
 668                         },
 669                         {
 670                                 .ifnum = 2,
 671                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 672                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 673                                         .out_cables = 0x0007,
 674                                         .in_cables  = 0x0007
 675                                 }
 676                         },
 677                         {
 678                                 .ifnum = -1
 679                         }
 680                 }
 681         }
 682 },
 683 {       /*
 684          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 685          * If the advanced mode switch at the back of the unit is off, the
 686          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 687          * but offers only 16-bit PCM.
 688          * In advanced mode, the UA-5 will output S24_3LE samples (two
 689          * channels) at the rate indicated on the front switch, including
 690          * the 96kHz sample rate.
 691          */
 692         USB_DEVICE(0x0582, 0x0010),
 693         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 694                 .vendor_name = "EDIROL",
 695                 .product_name = "UA-5",
 696                 .ifnum = QUIRK_ANY_INTERFACE,
 697                 .type = QUIRK_COMPOSITE,
 698                 .data = (const struct snd_usb_audio_quirk[]) {
 699                         {
 700                                 .ifnum = 1,
 701                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 702                         },
 703                         {
 704                                 .ifnum = 2,
 705                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 706                         },
 707                         {
 708                                 .ifnum = -1
 709                         }
 710                 }
 711         }
 712 },
 713 {
 714         /* has ID 0x0013 when not in "Advanced Driver" mode */
 715         USB_DEVICE(0x0582, 0x0012),
 716         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 717                 .vendor_name = "Roland",
 718                 .product_name = "XV-5050",
 719                 .ifnum = 0,
 720                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 721                 .data = & (const struct snd_usb_midi_endpoint_info) {
 722                         .out_cables = 0x0001,
 723                         .in_cables  = 0x0001
 724                 }
 725         }
 726 },
 727 {
 728         /* has ID 0x0015 when not in "Advanced Driver" mode */
 729         USB_DEVICE(0x0582, 0x0014),
 730         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 731                 .vendor_name = "EDIROL",
 732                 .product_name = "UM-880",
 733                 .ifnum = 0,
 734                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 735                 .data = & (const struct snd_usb_midi_endpoint_info) {
 736                         .out_cables = 0x01ff,
 737                         .in_cables  = 0x01ff
 738                 }
 739         }
 740 },
 741 {
 742         /* has ID 0x0017 when not in "Advanced Driver" mode */
 743         USB_DEVICE(0x0582, 0x0016),
 744         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 745                 .vendor_name = "EDIROL",
 746                 .product_name = "SD-90",
 747                 .ifnum = QUIRK_ANY_INTERFACE,
 748                 .type = QUIRK_COMPOSITE,
 749                 .data = (const struct snd_usb_audio_quirk[]) {
 750                         {
 751                                 .ifnum = 0,
 752                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 753                         },
 754                         {
 755                                 .ifnum = 1,
 756                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 757                         },
 758                         {
 759                                 .ifnum = 2,
 760                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 761                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 762                                         .out_cables = 0x000f,
 763                                         .in_cables  = 0x000f
 764                                 }
 765                         },
 766                         {
 767                                 .ifnum = -1
 768                         }
 769                 }
 770         }
 771 },
 772 {
 773         /* has ID 0x001c when not in "Advanced Driver" mode */
 774         USB_DEVICE(0x0582, 0x001b),
 775         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 776                 .vendor_name = "Roland",
 777                 .product_name = "MMP-2",
 778                 .ifnum = QUIRK_ANY_INTERFACE,
 779                 .type = QUIRK_COMPOSITE,
 780                 .data = (const struct snd_usb_audio_quirk[]) {
 781                         {
 782                                 .ifnum = 0,
 783                                 .type = QUIRK_IGNORE_INTERFACE
 784                         },
 785                         {
 786                                 .ifnum = 1,
 787                                 .type = QUIRK_IGNORE_INTERFACE
 788                         },
 789                         {
 790                                 .ifnum = 2,
 791                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 792                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 793                                         .out_cables = 0x0001,
 794                                         .in_cables  = 0x0001
 795                                 }
 796                         },
 797                         {
 798                                 .ifnum = -1
 799                         }
 800                 }
 801         }
 802 },
 803 {
 804         /* has ID 0x001e when not in "Advanced Driver" mode */
 805         USB_DEVICE(0x0582, 0x001d),
 806         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 807                 .vendor_name = "Roland",
 808                 .product_name = "V-SYNTH",
 809                 .ifnum = 0,
 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 {
 818         /* has ID 0x0024 when not in "Advanced Driver" mode */
 819         USB_DEVICE(0x0582, 0x0023),
 820         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 821                 .vendor_name = "EDIROL",
 822                 .product_name = "UM-550",
 823                 .ifnum = 0,
 824                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 825                 .data = & (const struct snd_usb_midi_endpoint_info) {
 826                         .out_cables = 0x003f,
 827                         .in_cables  = 0x003f
 828                 }
 829         }
 830 },
 831 {
 832         /*
 833          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 834          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 835          * and no MIDI.
 836          */
 837         USB_DEVICE(0x0582, 0x0025),
 838         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 839                 .vendor_name = "EDIROL",
 840                 .product_name = "UA-20",
 841                 .ifnum = QUIRK_ANY_INTERFACE,
 842                 .type = QUIRK_COMPOSITE,
 843                 .data = (const struct snd_usb_audio_quirk[]) {
 844                         {
 845                                 .ifnum = 0,
 846                                 .type = QUIRK_IGNORE_INTERFACE
 847                         },
 848                         {
 849                                 .ifnum = 1,
 850                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 851                                 .data = & (const struct audioformat) {
 852                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 853                                         .channels = 2,
 854                                         .iface = 1,
 855                                         .altsetting = 1,
 856                                         .altset_idx = 1,
 857                                         .attributes = 0,
 858                                         .endpoint = 0x01,
 859                                         .ep_attr = 0x01,
 860                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 861                                         .rate_min = 44100,
 862                                         .rate_max = 44100,
 863                                 }
 864                         },
 865                         {
 866                                 .ifnum = 2,
 867                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 868                                 .data = & (const struct audioformat) {
 869                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 870                                         .channels = 2,
 871                                         .iface = 2,
 872                                         .altsetting = 1,
 873                                         .altset_idx = 1,
 874                                         .attributes = 0,
 875                                         .endpoint = 0x82,
 876                                         .ep_attr = 0x01,
 877                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 878                                         .rate_min = 44100,
 879                                         .rate_max = 44100,
 880                                 }
 881                         },
 882                         {
 883                                 .ifnum = 3,
 884                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 885                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 886                                         .out_cables = 0x0001,
 887                                         .in_cables  = 0x0001
 888                                 }
 889                         },
 890                         {
 891                                 .ifnum = -1
 892                         }
 893                 }
 894         }
 895 },
 896 {
 897         /* has ID 0x0028 when not in "Advanced Driver" mode */
 898         USB_DEVICE(0x0582, 0x0027),
 899         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 900                 .vendor_name = "EDIROL",
 901                 .product_name = "SD-20",
 902                 .ifnum = 0,
 903                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 904                 .data = & (const struct snd_usb_midi_endpoint_info) {
 905                         .out_cables = 0x0003,
 906                         .in_cables  = 0x0007
 907                 }
 908         }
 909 },
 910 {
 911         /* has ID 0x002a when not in "Advanced Driver" mode */
 912         USB_DEVICE(0x0582, 0x0029),
 913         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 914                 .vendor_name = "EDIROL",
 915                 .product_name = "SD-80",
 916                 .ifnum = 0,
 917                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 918                 .data = & (const struct snd_usb_midi_endpoint_info) {
 919                         .out_cables = 0x000f,
 920                         .in_cables  = 0x000f
 921                 }
 922         }
 923 },
 924 {       /*
 925          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 926          * If the sample format switch is not in an advanced setting, the
 927          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 928          * but offers only 16-bit PCM and no MIDI.
 929          */
 930         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 931         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 932                 .vendor_name = "EDIROL",
 933                 .product_name = "UA-700",
 934                 .ifnum = QUIRK_ANY_INTERFACE,
 935                 .type = QUIRK_COMPOSITE,
 936                 .data = (const struct snd_usb_audio_quirk[]) {
 937                         {
 938                                 .ifnum = 1,
 939                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 940                         },
 941                         {
 942                                 .ifnum = 2,
 943                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 944                         },
 945                         {
 946                                 .ifnum = 3,
 947                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 948                         },
 949                         {
 950                                 .ifnum = -1
 951                         }
 952                 }
 953         }
 954 },
 955 {
 956         /* has ID 0x002e when not in "Advanced Driver" mode */
 957         USB_DEVICE(0x0582, 0x002d),
 958         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 959                 .vendor_name = "Roland",
 960                 .product_name = "XV-2020",
 961                 .ifnum = 0,
 962                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 963                 .data = & (const struct snd_usb_midi_endpoint_info) {
 964                         .out_cables = 0x0001,
 965                         .in_cables  = 0x0001
 966                 }
 967         }
 968 },
 969 {
 970         /* has ID 0x0030 when not in "Advanced Driver" mode */
 971         USB_DEVICE(0x0582, 0x002f),
 972         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 973                 .vendor_name = "Roland",
 974                 .product_name = "VariOS",
 975                 .ifnum = 0,
 976                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 977                 .data = & (const struct snd_usb_midi_endpoint_info) {
 978                         .out_cables = 0x0007,
 979                         .in_cables  = 0x0007
 980                 }
 981         }
 982 },
 983 {
 984         /* has ID 0x0034 when not in "Advanced Driver" mode */
 985         USB_DEVICE(0x0582, 0x0033),
 986         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 987                 .vendor_name = "EDIROL",
 988                 .product_name = "PCR",
 989                 .ifnum = 0,
 990                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 991                 .data = & (const struct snd_usb_midi_endpoint_info) {
 992                         .out_cables = 0x0003,
 993                         .in_cables  = 0x0007
 994                 }
 995         }
 996 },
 997         /* TODO: add Roland M-1000 support */
 998 {
 999         /*
1000          * Has ID 0x0038 when not in "Advanced Driver" mode;
1001          * later revisions use IDs 0x0054 and 0x00a2.
1002          */
1003         USB_DEVICE(0x0582, 0x0037),
1004         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1005                 .vendor_name = "Roland",
1006                 .product_name = "Digital Piano",
1007                 .ifnum = 0,
1008                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1009                 .data = & (const struct snd_usb_midi_endpoint_info) {
1010                         .out_cables = 0x0001,
1011                         .in_cables  = 0x0001
1012                 }
1013         }
1014 },
1015 {
1016         /*
1017          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
1018          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
1019          * and no MIDI.
1020          */
1021         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
1022         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1023                 .vendor_name = "BOSS",
1024                 .product_name = "GS-10",
1025                 .ifnum = QUIRK_ANY_INTERFACE,
1026                 .type = QUIRK_COMPOSITE,
1027                 .data = & (const struct snd_usb_audio_quirk[]) {
1028                         {
1029                                 .ifnum = 1,
1030                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1031                         },
1032                         {
1033                                 .ifnum = 2,
1034                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1035                         },
1036                         {
1037                                 .ifnum = 3,
1038                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1039                         },
1040                         {
1041                                 .ifnum = -1
1042                         }
1043                 }
1044         }
1045 },
1046 {
1047         /* has ID 0x0041 when not in "Advanced Driver" mode */
1048         USB_DEVICE(0x0582, 0x0040),
1049         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1050                 .vendor_name = "Roland",
1051                 .product_name = "GI-20",
1052                 .ifnum = 0,
1053                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1054                 .data = & (const struct snd_usb_midi_endpoint_info) {
1055                         .out_cables = 0x0001,
1056                         .in_cables  = 0x0001
1057                 }
1058         }
1059 },
1060 {
1061         /* has ID 0x0043 when not in "Advanced Driver" mode */
1062         USB_DEVICE(0x0582, 0x0042),
1063         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1064                 .vendor_name = "Roland",
1065                 .product_name = "RS-70",
1066                 .ifnum = 0,
1067                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1068                 .data = & (const struct snd_usb_midi_endpoint_info) {
1069                         .out_cables = 0x0001,
1070                         .in_cables  = 0x0001
1071                 }
1072         }
1073 },
1074 {
1075         /* has ID 0x0049 when not in "Advanced Driver" mode */
1076         USB_DEVICE(0x0582, 0x0047),
1077         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1078                 /* .vendor_name = "EDIROL", */
1079                 /* .product_name = "UR-80", */
1080                 .ifnum = QUIRK_ANY_INTERFACE,
1081                 .type = QUIRK_COMPOSITE,
1082                 .data = (const struct snd_usb_audio_quirk[]) {
1083                         /* in the 96 kHz modes, only interface 1 is there */
1084                         {
1085                                 .ifnum = 1,
1086                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1087                         },
1088                         {
1089                                 .ifnum = 2,
1090                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1091                         },
1092                         {
1093                                 .ifnum = -1
1094                         }
1095                 }
1096         }
1097 },
1098 {
1099         /* has ID 0x004a when not in "Advanced Driver" mode */
1100         USB_DEVICE(0x0582, 0x0048),
1101         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1102                 /* .vendor_name = "EDIROL", */
1103                 /* .product_name = "UR-80", */
1104                 .ifnum = 0,
1105                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1106                 .data = & (const struct snd_usb_midi_endpoint_info) {
1107                         .out_cables = 0x0003,
1108                         .in_cables  = 0x0007
1109                 }
1110         }
1111 },
1112         /* TODO: add Edirol M-100FX support */
1113 {
1114         /* has ID 0x004e when not in "Advanced Driver" mode */
1115         USB_DEVICE(0x0582, 0x004c),
1116         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1117                 .vendor_name = "EDIROL",
1118                 .product_name = "PCR-A",
1119                 .ifnum = QUIRK_ANY_INTERFACE,
1120                 .type = QUIRK_COMPOSITE,
1121                 .data = (const struct snd_usb_audio_quirk[]) {
1122                         {
1123                                 .ifnum = 1,
1124                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1125                         },
1126                         {
1127                                 .ifnum = 2,
1128                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1129                         },
1130                         {
1131                                 .ifnum = -1
1132                         }
1133                 }
1134         }
1135 },
1136 {
1137         /* has ID 0x004f when not in "Advanced Driver" mode */
1138         USB_DEVICE(0x0582, 0x004d),
1139         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1140                 .vendor_name = "EDIROL",
1141                 .product_name = "PCR-A",
1142                 .ifnum = 0,
1143                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1144                 .data = & (const struct snd_usb_midi_endpoint_info) {
1145                         .out_cables = 0x0003,
1146                         .in_cables  = 0x0007
1147                 }
1148         }
1149 },
1150 {
1151         /*
1152          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1153          * is standard compliant, but has only 16-bit PCM.
1154          */
1155         USB_DEVICE(0x0582, 0x0050),
1156         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1157                 .vendor_name = "EDIROL",
1158                 .product_name = "UA-3FX",
1159                 .ifnum = QUIRK_ANY_INTERFACE,
1160                 .type = QUIRK_COMPOSITE,
1161                 .data = (const struct snd_usb_audio_quirk[]) {
1162                         {
1163                                 .ifnum = 1,
1164                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1165                         },
1166                         {
1167                                 .ifnum = 2,
1168                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1169                         },
1170                         {
1171                                 .ifnum = -1
1172                         }
1173                 }
1174         }
1175 },
1176 {
1177         USB_DEVICE(0x0582, 0x0052),
1178         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1179                 .vendor_name = "EDIROL",
1180                 .product_name = "UM-1SX",
1181                 .ifnum = 0,
1182                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1183         }
1184 },
1185 {
1186         USB_DEVICE(0x0582, 0x0060),
1187         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1188                 .vendor_name = "Roland",
1189                 .product_name = "EXR Series",
1190                 .ifnum = 0,
1191                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1192         }
1193 },
1194 {
1195         /* has ID 0x0066 when not in "Advanced Driver" mode */
1196         USB_DEVICE(0x0582, 0x0064),
1197         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1198                 /* .vendor_name = "EDIROL", */
1199                 /* .product_name = "PCR-1", */
1200                 .ifnum = QUIRK_ANY_INTERFACE,
1201                 .type = QUIRK_COMPOSITE,
1202                 .data = (const struct snd_usb_audio_quirk[]) {
1203                         {
1204                                 .ifnum = 1,
1205                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1206                         },
1207                         {
1208                                 .ifnum = 2,
1209                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1210                         },
1211                         {
1212                                 .ifnum = -1
1213                         }
1214                 }
1215         }
1216 },
1217 {
1218         /* has ID 0x0067 when not in "Advanced Driver" mode */
1219         USB_DEVICE(0x0582, 0x0065),
1220         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1221                 /* .vendor_name = "EDIROL", */
1222                 /* .product_name = "PCR-1", */
1223                 .ifnum = 0,
1224                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1225                 .data = & (const struct snd_usb_midi_endpoint_info) {
1226                         .out_cables = 0x0001,
1227                         .in_cables  = 0x0003
1228                 }
1229         }
1230 },
1231 {
1232         /* has ID 0x006b when not in "Advanced Driver" mode */
1233         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1234         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1235                 .vendor_name = "Roland",
1236                 .product_name = "SP-606",
1237                 .ifnum = 3,
1238                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1239                 .data = & (const struct snd_usb_midi_endpoint_info) {
1240                         .out_cables = 0x0001,
1241                         .in_cables  = 0x0001
1242                 }
1243         }
1244 },
1245 {
1246         /* has ID 0x006e when not in "Advanced Driver" mode */
1247         USB_DEVICE(0x0582, 0x006d),
1248         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1249                 .vendor_name = "Roland",
1250                 .product_name = "FANTOM-X",
1251                 .ifnum = 0,
1252                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1253                 .data = & (const struct snd_usb_midi_endpoint_info) {
1254                         .out_cables = 0x0001,
1255                         .in_cables  = 0x0001
1256                 }
1257         }
1258 },
1259 {       /*
1260          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1261          * If the switch is not in an advanced setting, the UA-25 has
1262          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1263          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1264          */
1265         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1266         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1267                 .vendor_name = "EDIROL",
1268                 .product_name = "UA-25",
1269                 .ifnum = QUIRK_ANY_INTERFACE,
1270                 .type = QUIRK_COMPOSITE,
1271                 .data = (const struct snd_usb_audio_quirk[]) {
1272                         {
1273                                 .ifnum = 0,
1274                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1275                         },
1276                         {
1277                                 .ifnum = 1,
1278                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1279                         },
1280                         {
1281                                 .ifnum = 2,
1282                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1283                         },
1284                         {
1285                                 .ifnum = -1
1286                         }
1287                 }
1288         }
1289 },
1290 {
1291         /* has ID 0x0076 when not in "Advanced Driver" mode */
1292         USB_DEVICE(0x0582, 0x0075),
1293         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1294                 .vendor_name = "BOSS",
1295                 .product_name = "DR-880",
1296                 .ifnum = 0,
1297                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1298                 .data = & (const struct snd_usb_midi_endpoint_info) {
1299                         .out_cables = 0x0001,
1300                         .in_cables  = 0x0001
1301                 }
1302         }
1303 },
1304 {
1305         /* has ID 0x007b when not in "Advanced Driver" mode */
1306         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1307         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1308                 .vendor_name = "Roland",
1309                 /* "RD" or "RD-700SX"? */
1310                 .ifnum = 0,
1311                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1312                 .data = & (const struct snd_usb_midi_endpoint_info) {
1313                         .out_cables = 0x0003,
1314                         .in_cables  = 0x0003
1315                 }
1316         }
1317 },
1318 {
1319         /* has ID 0x0081 when not in "Advanced Driver" mode */
1320         USB_DEVICE(0x0582, 0x0080),
1321         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1322                 .vendor_name = "Roland",
1323                 .product_name = "G-70",
1324                 .ifnum = 0,
1325                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1326                 .data = & (const struct snd_usb_midi_endpoint_info) {
1327                         .out_cables = 0x0001,
1328                         .in_cables  = 0x0001
1329                 }
1330         }
1331 },
1332         /* TODO: add Roland V-SYNTH XT support */
1333         /* TODO: add BOSS GT-PRO support */
1334 {
1335         /* has ID 0x008c when not in "Advanced Driver" mode */
1336         USB_DEVICE(0x0582, 0x008b),
1337         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1338                 .vendor_name = "EDIROL",
1339                 .product_name = "PC-50",
1340                 .ifnum = 0,
1341                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1342                 .data = & (const struct snd_usb_midi_endpoint_info) {
1343                         .out_cables = 0x0001,
1344                         .in_cables  = 0x0001
1345                 }
1346         }
1347 },
1348         /* TODO: add Edirol PC-80 support */
1349 {
1350         USB_DEVICE(0x0582, 0x0096),
1351         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1352                 .vendor_name = "EDIROL",
1353                 .product_name = "UA-1EX",
1354                 .ifnum = QUIRK_ANY_INTERFACE,
1355                 .type = QUIRK_COMPOSITE,
1356                 .data = (const struct snd_usb_audio_quirk[]) {
1357                         {
1358                                 .ifnum = 0,
1359                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1360                         },
1361                         {
1362                                 .ifnum = 1,
1363                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1364                         },
1365                         {
1366                                 .ifnum = -1
1367                         }
1368                 }
1369         }
1370 },
1371 {
1372         USB_DEVICE(0x0582, 0x009a),
1373         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1374                 .vendor_name = "EDIROL",
1375                 .product_name = "UM-3EX",
1376                 .ifnum = 0,
1377                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1378                 .data = & (const struct snd_usb_midi_endpoint_info) {
1379                         .out_cables = 0x000f,
1380                         .in_cables  = 0x000f
1381                 }
1382         }
1383 },
1384 {
1385         /*
1386          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1387          * is standard compliant, but has only 16-bit PCM and no MIDI.
1388          */
1389         USB_DEVICE(0x0582, 0x00a3),
1390         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1391                 .vendor_name = "EDIROL",
1392                 .product_name = "UA-4FX",
1393                 .ifnum = QUIRK_ANY_INTERFACE,
1394                 .type = QUIRK_COMPOSITE,
1395                 .data = (const struct snd_usb_audio_quirk[]) {
1396                         {
1397                                 .ifnum = 0,
1398                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1399                         },
1400                         {
1401                                 .ifnum = 1,
1402                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1403                         },
1404                         {
1405                                 .ifnum = 2,
1406                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1407                         },
1408                         {
1409                                 .ifnum = -1
1410                         }
1411                 }
1412         }
1413 },
1414         /* TODO: add Edirol MD-P1 support */
1415 {
1416         USB_DEVICE(0x582, 0x00a6),
1417         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1418                 .vendor_name = "Roland",
1419                 .product_name = "Juno-G",
1420                 .ifnum = 0,
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 {
1429         /* Roland SH-201 */
1430         USB_DEVICE(0x0582, 0x00ad),
1431         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1432                 .vendor_name = "Roland",
1433                 .product_name = "SH-201",
1434                 .ifnum = QUIRK_ANY_INTERFACE,
1435                 .type = QUIRK_COMPOSITE,
1436                 .data = (const struct snd_usb_audio_quirk[]) {
1437                         {
1438                                 .ifnum = 0,
1439                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1440                         },
1441                         {
1442                                 .ifnum = 1,
1443                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1444                         },
1445                         {
1446                                 .ifnum = 2,
1447                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1448                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1449                                         .out_cables = 0x0001,
1450                                         .in_cables  = 0x0001
1451                                 }
1452                         },
1453                         {
1454                                 .ifnum = -1
1455                         }
1456                 }
1457         }
1458 },
1459 {
1460         /* Advanced mode of the Roland VG-99, with MIDI and 24-bit PCM at 44.1
1461          * kHz. In standard mode, the device has ID 0582:00b3, and offers
1462          * 16-bit PCM at 44.1 kHz with no MIDI.
1463          */
1464         USB_DEVICE(0x0582, 0x00b2),
1465         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1466                 .vendor_name = "Roland",
1467                 .product_name = "VG-99",
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 = 0x0003,
1484                                         .in_cables  = 0x0003
1485                                 }
1486                         },
1487                         {
1488                                 .ifnum = -1
1489                         }
1490                 }
1491         }
1492 },
1493 {
1494         /* Roland SonicCell */
1495         USB_DEVICE(0x0582, 0x00c2),
1496         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1497                 .vendor_name = "Roland",
1498                 .product_name = "SonicCell",
1499                 .ifnum = QUIRK_ANY_INTERFACE,
1500                 .type = QUIRK_COMPOSITE,
1501                 .data = (const struct snd_usb_audio_quirk[]) {
1502                         {
1503                                 .ifnum = 0,
1504                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1505                         },
1506                         {
1507                                 .ifnum = 1,
1508                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1509                         },
1510                         {
1511                                 .ifnum = 2,
1512                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1513                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1514                                         .out_cables = 0x0001,
1515                                         .in_cables  = 0x0001
1516                                 }
1517                         },
1518                         {
1519                                 .ifnum = -1
1520                         }
1521                 }
1522         }
1523 },
1524 {
1525         /* Edirol M-16DX */
1526         /* FIXME: This quirk gives a good-working capture stream but the
1527          *        playback seems problematic because of lacking of sync
1528          *        with capture stream.  It needs to sync with the capture
1529          *        clock.  As now, you'll get frequent sound distortions
1530          *        via the playback.
1531          */
1532         USB_DEVICE(0x0582, 0x00c4),
1533         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1534                 .ifnum = QUIRK_ANY_INTERFACE,
1535                 .type = QUIRK_COMPOSITE,
1536                 .data = (const struct snd_usb_audio_quirk[]) {
1537                         {
1538                                 .ifnum = 0,
1539                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1540                         },
1541                         {
1542                                 .ifnum = 1,
1543                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1544                         },
1545                         {
1546                                 .ifnum = 2,
1547                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1548                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1549                                         .out_cables = 0x0001,
1550                                         .in_cables  = 0x0001
1551                                 }
1552                         },
1553                         {
1554                                 .ifnum = -1
1555                         }
1556                 }
1557         }
1558 },
1559 {
1560         /* BOSS GT-10 */
1561         USB_DEVICE(0x0582, 0x00da),
1562         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1563                 .ifnum = QUIRK_ANY_INTERFACE,
1564                 .type = QUIRK_COMPOSITE,
1565                 .data = (const struct snd_usb_audio_quirk[]) {
1566                         {
1567                                 .ifnum = 0,
1568                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1569                         },
1570                         {
1571                                 .ifnum = 1,
1572                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1573                         },
1574                         {
1575                                 .ifnum = 2,
1576                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1577                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1578                                         .out_cables = 0x0001,
1579                                         .in_cables  = 0x0001
1580                                 }
1581                         },
1582                         {
1583                                 .ifnum = -1
1584                         }
1585                 }
1586         }
1587 },
1588 {
1589         /* Advanced modes of the Edirol UA-25EX.
1590          * For the standard mode, UA-25EX has ID 0582:00e7, which
1591          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1592          */
1593         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1594         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1595                 .vendor_name = "EDIROL",
1596                 .product_name = "UA-25EX",
1597                 .ifnum = QUIRK_ANY_INTERFACE,
1598                 .type = QUIRK_COMPOSITE,
1599                 .data = (const struct snd_usb_audio_quirk[]) {
1600                         {
1601                                 .ifnum = 0,
1602                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1603                         },
1604                         {
1605                                 .ifnum = 1,
1606                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1607                         },
1608                         {
1609                                 .ifnum = 2,
1610                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1611                         },
1612                         {
1613                                 .ifnum = -1
1614                         }
1615                 }
1616         }
1617 },
1618 {
1619         /* has ID 0x00ea when not in Advanced Driver mode */
1620         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1621         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1622                 /* .vendor_name = "Roland", */
1623                 /* .product_name = "UA-1G", */
1624                 .ifnum = QUIRK_ANY_INTERFACE,
1625                 .type = QUIRK_COMPOSITE,
1626                 .data = (const struct snd_usb_audio_quirk[]) {
1627                         {
1628                                 .ifnum = 0,
1629                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1630                         },
1631                         {
1632                                 .ifnum = 1,
1633                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1634                         },
1635                         {
1636                                 .ifnum = -1
1637                         }
1638                 }
1639         }
1640 },
1641 {
1642         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1643         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1644                 /* .vendor_name = "Roland", */
1645                 /* .product_name = "UM-1G", */
1646                 .ifnum = 0,
1647                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1648                 .data = & (const struct snd_usb_midi_endpoint_info) {
1649                         .out_cables = 0x0001,
1650                         .in_cables  = 0x0001
1651                 }
1652         }
1653 },
1654 {
1655         /* Edirol UM-3G */
1656         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
1657         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1658                 .ifnum = 0,
1659                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1660         }
1661 },
1662 {
1663         /* Boss JS-8 Jam Station  */
1664         USB_DEVICE(0x0582, 0x0109),
1665         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1666                 /* .vendor_name = "BOSS", */
1667                 /* .product_name = "JS-8", */
1668                 .ifnum = QUIRK_ANY_INTERFACE,
1669                 .type = QUIRK_COMPOSITE,
1670                 .data = (const struct snd_usb_audio_quirk[]) {
1671                         {
1672                                 .ifnum = 0,
1673                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1674                         },
1675                         {
1676                                 .ifnum = 1,
1677                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1678                         },
1679                         {
1680                                 .ifnum = 2,
1681                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1682                         },
1683                         {
1684                                 .ifnum = -1
1685                         }
1686                 }
1687         }
1688 },
1689 {
1690         /* has ID 0x0110 when not in Advanced Driver mode */
1691         USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1692         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1693                 /* .vendor_name = "Roland", */
1694                 /* .product_name = "A-PRO", */
1695                 .ifnum = 1,
1696                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1697                 .data = & (const struct snd_usb_midi_endpoint_info) {
1698                         .out_cables = 0x0003,
1699                         .in_cables  = 0x0007
1700                 }
1701         }
1702 },
1703 {
1704         /* Roland GAIA SH-01 */
1705         USB_DEVICE(0x0582, 0x0111),
1706         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1707                 .vendor_name = "Roland",
1708                 .product_name = "GAIA",
1709                 .ifnum = QUIRK_ANY_INTERFACE,
1710                 .type = QUIRK_COMPOSITE,
1711                 .data = (const struct snd_usb_audio_quirk[]) {
1712                         {
1713                                 .ifnum = 0,
1714                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1715                         },
1716                         {
1717                                 .ifnum = 1,
1718                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1719                         },
1720                         {
1721                                 .ifnum = 2,
1722                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1723                                 .data = &(const struct snd_usb_midi_endpoint_info) {
1724                                 .out_cables = 0x0003,
1725                                 .in_cables  = 0x0003
1726                                 }
1727                         },
1728                         {
1729                                 .ifnum = -1
1730                         }
1731                 }
1732         }
1733 },
1734 {
1735         USB_DEVICE(0x0582, 0x0113),
1736         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1737                 /* .vendor_name = "BOSS", */
1738                 /* .product_name = "ME-25", */
1739                 .ifnum = QUIRK_ANY_INTERFACE,
1740                 .type = QUIRK_COMPOSITE,
1741                 .data = (const struct snd_usb_audio_quirk[]) {
1742                         {
1743                                 .ifnum = 0,
1744                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1745                         },
1746                         {
1747                                 .ifnum = 1,
1748                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1749                         },
1750                         {
1751                                 .ifnum = 2,
1752                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1753                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1754                                         .out_cables = 0x0001,
1755                                         .in_cables  = 0x0001
1756                                 }
1757                         },
1758                         {
1759                                 .ifnum = -1
1760                         }
1761                 }
1762         }
1763 },
1764 {
1765         USB_DEVICE(0x0582, 0x0127),
1766         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1767                 /* .vendor_name = "Roland", */
1768                 /* .product_name = "GR-55", */
1769                 .ifnum = QUIRK_ANY_INTERFACE,
1770                 .type = QUIRK_COMPOSITE,
1771                 .data = (const struct snd_usb_audio_quirk[]) {
1772                         {
1773                                 .ifnum = 0,
1774                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1775                         },
1776                         {
1777                                 .ifnum = 1,
1778                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1779                         },
1780                         {
1781                                 .ifnum = 2,
1782                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1783                         },
1784                         {
1785                                 .ifnum = -1
1786                         }
1787                 }
1788         }
1789 },
1790 {
1791         /* Added support for Roland UM-ONE which differs from UM-1 */
1792         USB_DEVICE(0x0582, 0x012a),
1793         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1794                 /* .vendor_name = "ROLAND", */
1795                 /* .product_name = "UM-ONE", */
1796                 .ifnum = 0,
1797                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1798                 .data = & (const struct snd_usb_midi_endpoint_info) {
1799                         .out_cables = 0x0001,
1800                         .in_cables  = 0x0003
1801                 }
1802         }
1803 },
1804 {
1805         USB_DEVICE(0x0582, 0x011e),
1806         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1807                 /* .vendor_name = "BOSS", */
1808                 /* .product_name = "BR-800", */
1809                 .ifnum = QUIRK_ANY_INTERFACE,
1810                 .type = QUIRK_COMPOSITE,
1811                 .data = (const struct snd_usb_audio_quirk[]) {
1812                         {
1813                                 .ifnum = 0,
1814                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1815                         },
1816                         {
1817                                 .ifnum = 1,
1818                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1819                         },
1820                         {
1821                                 .ifnum = 2,
1822                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1823                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1824                                         .out_cables = 0x0001,
1825                                         .in_cables  = 0x0001
1826                                 }
1827                         },
1828                         {
1829                                 .ifnum = -1
1830                         }
1831                 }
1832         }
1833 },
1834 {
1835         USB_DEVICE(0x0582, 0x0130),
1836         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1837                 /* .vendor_name = "BOSS", */
1838                 /* .product_name = "MICRO BR-80", */
1839                 .ifnum = QUIRK_ANY_INTERFACE,
1840                 .type = QUIRK_COMPOSITE,
1841                 .data = (const struct snd_usb_audio_quirk[]) {
1842                         {
1843                                 .ifnum = 0,
1844                                 .type = QUIRK_IGNORE_INTERFACE
1845                         },
1846                         {
1847                                 .ifnum = 1,
1848                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1849                         },
1850                         {
1851                                 .ifnum = 2,
1852                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1853                         },
1854                         {
1855                                 .ifnum = 3,
1856                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1857                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1858                                         .out_cables = 0x0001,
1859                                         .in_cables  = 0x0001
1860                                 }
1861                         },
1862                         {
1863                                 .ifnum = -1
1864                         }
1865                 }
1866         }
1867 },
1868 {
1869         USB_DEVICE(0x0582, 0x014d),
1870         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1871                 /* .vendor_name = "BOSS", */
1872                 /* .product_name = "GT-100", */
1873                 .ifnum = QUIRK_ANY_INTERFACE,
1874                 .type = QUIRK_COMPOSITE,
1875                 .data = (const struct snd_usb_audio_quirk[]) {
1876                         {
1877                                 .ifnum = 1,
1878                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1879                         },
1880                         {
1881                                 .ifnum = 2,
1882                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1883                         },
1884                         {
1885                                 .ifnum = 3,
1886                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1887                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1888                                         .out_cables = 0x0001,
1889                                         .in_cables  = 0x0001
1890                                 }
1891                         },
1892                         {
1893                                 .ifnum = -1
1894                         }
1895                 }
1896         }
1897 },
1898
1899 /* Guillemot devices */
1900 {
1901         /*
1902          * This is for the "Windows Edition" where the external MIDI ports are
1903          * the only MIDI ports; the control data is reported through HID
1904          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1905          * compliant USB MIDI ports for external MIDI and controls.
1906          */
1907         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1908         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1909                 .vendor_name = "Hercules",
1910                 .product_name = "DJ Console (WE)",
1911                 .ifnum = 4,
1912                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1913                 .data = & (const struct snd_usb_midi_endpoint_info) {
1914                         .out_cables = 0x0001,
1915                         .in_cables = 0x0001
1916                 }
1917         }
1918 },
1919
1920 /* Midiman/M-Audio devices */
1921 {
1922         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1923         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1924                 .vendor_name = "M-Audio",
1925                 .product_name = "MidiSport 2x2",
1926                 .ifnum = QUIRK_ANY_INTERFACE,
1927                 .type = QUIRK_MIDI_MIDIMAN,
1928                 .data = & (const struct snd_usb_midi_endpoint_info) {
1929                         .out_cables = 0x0003,
1930                         .in_cables  = 0x0003
1931                 }
1932         }
1933 },
1934 {
1935         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1936         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1937                 .vendor_name = "M-Audio",
1938                 .product_name = "MidiSport 1x1",
1939                 .ifnum = QUIRK_ANY_INTERFACE,
1940                 .type = QUIRK_MIDI_MIDIMAN,
1941                 .data = & (const struct snd_usb_midi_endpoint_info) {
1942                         .out_cables = 0x0001,
1943                         .in_cables  = 0x0001
1944                 }
1945         }
1946 },
1947 {
1948         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1949         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1950                 .vendor_name = "M-Audio",
1951                 .product_name = "Keystation",
1952                 .ifnum = QUIRK_ANY_INTERFACE,
1953                 .type = QUIRK_MIDI_MIDIMAN,
1954                 .data = & (const struct snd_usb_midi_endpoint_info) {
1955                         .out_cables = 0x0001,
1956                         .in_cables  = 0x0001
1957                 }
1958         }
1959 },
1960 {
1961         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1962         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1963                 .vendor_name = "M-Audio",
1964                 .product_name = "MidiSport 4x4",
1965                 .ifnum = QUIRK_ANY_INTERFACE,
1966                 .type = QUIRK_MIDI_MIDIMAN,
1967                 .data = & (const struct snd_usb_midi_endpoint_info) {
1968                         .out_cables = 0x000f,
1969                         .in_cables  = 0x000f
1970                 }
1971         }
1972 },
1973 {
1974         /*
1975          * For hardware revision 1.05; in the later revisions (1.10 and
1976          * 1.21), 0x1031 is the ID for the device without firmware.
1977          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1978          */
1979         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1980         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1981                 .vendor_name = "M-Audio",
1982                 .product_name = "MidiSport 8x8",
1983                 .ifnum = QUIRK_ANY_INTERFACE,
1984                 .type = QUIRK_MIDI_MIDIMAN,
1985                 .data = & (const struct snd_usb_midi_endpoint_info) {
1986                         .out_cables = 0x01ff,
1987                         .in_cables  = 0x01ff
1988                 }
1989         }
1990 },
1991 {
1992         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1993         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1994                 .vendor_name = "M-Audio",
1995                 .product_name = "MidiSport 8x8",
1996                 .ifnum = QUIRK_ANY_INTERFACE,
1997                 .type = QUIRK_MIDI_MIDIMAN,
1998                 .data = & (const struct snd_usb_midi_endpoint_info) {
1999                         .out_cables = 0x01ff,
2000                         .in_cables  = 0x01ff
2001                 }
2002         }
2003 },
2004 {
2005         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
2006         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2007                 .vendor_name = "M-Audio",
2008                 .product_name = "MidiSport 2x4",
2009                 .ifnum = QUIRK_ANY_INTERFACE,
2010                 .type = QUIRK_MIDI_MIDIMAN,
2011                 .data = & (const struct snd_usb_midi_endpoint_info) {
2012                         .out_cables = 0x000f,
2013                         .in_cables  = 0x0003
2014                 }
2015         }
2016 },
2017 {
2018         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
2019         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2020                 .vendor_name = "M-Audio",
2021                 .product_name = "Quattro",
2022                 .ifnum = QUIRK_ANY_INTERFACE,
2023                 .type = QUIRK_COMPOSITE,
2024                 .data = & (const struct snd_usb_audio_quirk[]) {
2025                         /*
2026                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
2027                          * and share endpoints with the other interfaces.
2028                          * Ignore them.  The other interfaces can do 24 bits,
2029                          * but captured samples are big-endian (see usbaudio.c).
2030                          */
2031                         {
2032                                 .ifnum = 0,
2033                                 .type = QUIRK_IGNORE_INTERFACE
2034                         },
2035                         {
2036                                 .ifnum = 1,
2037                                 .type = QUIRK_IGNORE_INTERFACE
2038                         },
2039                         {
2040                                 .ifnum = 2,
2041                                 .type = QUIRK_IGNORE_INTERFACE
2042                         },
2043                         {
2044                                 .ifnum = 3,
2045                                 .type = QUIRK_IGNORE_INTERFACE
2046                         },
2047                         {
2048                                 .ifnum = 4,
2049                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2050                         },
2051                         {
2052                                 .ifnum = 5,
2053                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2054                         },
2055                         {
2056                                 .ifnum = 6,
2057                                 .type = QUIRK_IGNORE_INTERFACE
2058                         },
2059                         {
2060                                 .ifnum = 7,
2061                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2062                         },
2063                         {
2064                                 .ifnum = 8,
2065                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2066                         },
2067                         {
2068                                 .ifnum = 9,
2069                                 .type = QUIRK_MIDI_MIDIMAN,
2070                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2071                                         .out_cables = 0x0001,
2072                                         .in_cables  = 0x0001
2073                                 }
2074                         },
2075                         {
2076                                 .ifnum = -1
2077                         }
2078                 }
2079         }
2080 },
2081 {
2082         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2083         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2084                 .vendor_name = "M-Audio",
2085                 .product_name = "AudioPhile",
2086                 .ifnum = 6,
2087                 .type = QUIRK_MIDI_MIDIMAN,
2088                 .data = & (const struct snd_usb_midi_endpoint_info) {
2089                         .out_cables = 0x0001,
2090                         .in_cables  = 0x0001
2091                 }
2092         }
2093 },
2094 {
2095         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2096         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2097                 .vendor_name = "M-Audio",
2098                 .product_name = "Ozone",
2099                 .ifnum = 3,
2100                 .type = QUIRK_MIDI_MIDIMAN,
2101                 .data = & (const struct snd_usb_midi_endpoint_info) {
2102                         .out_cables = 0x0001,
2103                         .in_cables  = 0x0001
2104                 }
2105         }
2106 },
2107 {
2108         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2109         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2110                 .vendor_name = "M-Audio",
2111                 .product_name = "OmniStudio",
2112                 .ifnum = QUIRK_ANY_INTERFACE,
2113                 .type = QUIRK_COMPOSITE,
2114                 .data = & (const struct snd_usb_audio_quirk[]) {
2115                         {
2116                                 .ifnum = 0,
2117                                 .type = QUIRK_IGNORE_INTERFACE
2118                         },
2119                         {
2120                                 .ifnum = 1,
2121                                 .type = QUIRK_IGNORE_INTERFACE
2122                         },
2123                         {
2124                                 .ifnum = 2,
2125                                 .type = QUIRK_IGNORE_INTERFACE
2126                         },
2127                         {
2128                                 .ifnum = 3,
2129                                 .type = QUIRK_IGNORE_INTERFACE
2130                         },
2131                         {
2132                                 .ifnum = 4,
2133                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2134                         },
2135                         {
2136                                 .ifnum = 5,
2137                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2138                         },
2139                         {
2140                                 .ifnum = 6,
2141                                 .type = QUIRK_IGNORE_INTERFACE
2142                         },
2143                         {
2144                                 .ifnum = 7,
2145                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2146                         },
2147                         {
2148                                 .ifnum = 8,
2149                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2150                         },
2151                         {
2152                                 .ifnum = 9,
2153                                 .type = QUIRK_MIDI_MIDIMAN,
2154                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2155                                         .out_cables = 0x0001,
2156                                         .in_cables  = 0x0001
2157                                 }
2158                         },
2159                         {
2160                                 .ifnum = -1
2161                         }
2162                 }
2163         }
2164 },
2165 {
2166         USB_DEVICE(0x0763, 0x2019),
2167         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2168                 /* .vendor_name = "M-Audio", */
2169                 /* .product_name = "Ozone Academic", */
2170                 .ifnum = QUIRK_ANY_INTERFACE,
2171                 .type = QUIRK_COMPOSITE,
2172                 .data = & (const struct snd_usb_audio_quirk[]) {
2173                         {
2174                                 .ifnum = 0,
2175                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2176                         },
2177                         {
2178                                 .ifnum = 1,
2179                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2180                         },
2181                         {
2182                                 .ifnum = 2,
2183                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2184                         },
2185                         {
2186                                 .ifnum = 3,
2187                                 .type = QUIRK_MIDI_MIDIMAN,
2188                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2189                                         .out_cables = 0x0001,
2190                                         .in_cables  = 0x0001
2191                                 }
2192                         },
2193                         {
2194                                 .ifnum = -1
2195                         }
2196                 }
2197         }
2198 },
2199 {
2200         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
2201         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2202                 /* .vendor_name = "M-Audio", */
2203                 /* .product_name = "Fast Track C400", */
2204                 .ifnum = QUIRK_ANY_INTERFACE,
2205                 .type = QUIRK_COMPOSITE,
2206                 .data = &(const struct snd_usb_audio_quirk[]) {
2207                         {
2208                                 .ifnum = 1,
2209                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2210                         },
2211                         /* Playback */
2212                         {
2213                                 .ifnum = 2,
2214                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2215                                 .data = &(const struct audioformat) {
2216                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2217                                         .channels = 6,
2218                                         .iface = 2,
2219                                         .altsetting = 1,
2220                                         .altset_idx = 1,
2221                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2222                                         .endpoint = 0x01,
2223                                         .ep_attr = 0x09,
2224                                         .rates = SNDRV_PCM_RATE_44100 |
2225                                                  SNDRV_PCM_RATE_48000 |
2226                                                  SNDRV_PCM_RATE_88200 |
2227                                                  SNDRV_PCM_RATE_96000,
2228                                         .rate_min = 44100,
2229                                         .rate_max = 96000,
2230                                         .nr_rates = 4,
2231                                         .rate_table = (unsigned int[]) {
2232                                                         44100, 48000, 88200, 96000
2233                                         },
2234                                         .clock = 0x81,
2235                                 }
2236                         },
2237                         /* Capture */
2238                         {
2239                                 .ifnum = 3,
2240                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2241                                 .data = &(const struct audioformat) {
2242                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2243                                         .channels = 4,
2244                                         .iface = 3,
2245                                         .altsetting = 1,
2246                                         .altset_idx = 1,
2247                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2248                                         .endpoint = 0x81,
2249                                         .ep_attr = 0x05,
2250                                         .rates = SNDRV_PCM_RATE_44100 |
2251                                                  SNDRV_PCM_RATE_48000 |
2252                                                  SNDRV_PCM_RATE_88200 |
2253                                                  SNDRV_PCM_RATE_96000,
2254                                         .rate_min = 44100,
2255                                         .rate_max = 96000,
2256                                         .nr_rates = 4,
2257                                         .rate_table = (unsigned int[]) {
2258                                                 44100, 48000, 88200, 96000
2259                                         },
2260                                         .clock = 0x81,
2261                                 }
2262                         },
2263                         /* MIDI */
2264                         {
2265                                 .ifnum = -1 /* Interface = 4 */
2266                         }
2267                 }
2268         }
2269 },
2270 {
2271         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2272         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2273                 /* .vendor_name = "M-Audio", */
2274                 /* .product_name = "Fast Track Ultra", */
2275                 .ifnum = QUIRK_ANY_INTERFACE,
2276                 .type = QUIRK_COMPOSITE,
2277                 .data = & (const struct snd_usb_audio_quirk[]) {
2278                         {
2279                                 .ifnum = 0,
2280                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2281                         },
2282                         {
2283                                 .ifnum = 1,
2284                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2285                                 .data = & (const struct audioformat) {
2286                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2287                                         .channels = 8,
2288                                         .iface = 1,
2289                                         .altsetting = 1,
2290                                         .altset_idx = 1,
2291                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2292                                         .endpoint = 0x01,
2293                                         .ep_attr = 0x09,
2294                                         .rates = SNDRV_PCM_RATE_44100 |
2295                                                  SNDRV_PCM_RATE_48000 |
2296                                                  SNDRV_PCM_RATE_88200 |
2297                                                  SNDRV_PCM_RATE_96000,
2298                                         .rate_min = 44100,
2299                                         .rate_max = 96000,
2300                                         .nr_rates = 4,
2301                                         .rate_table = (unsigned int[]) {
2302                                                 44100, 48000, 88200, 96000
2303                                         }
2304                                 }
2305                         },
2306                         {
2307                                 .ifnum = 2,
2308                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2309                                 .data = & (const struct audioformat) {
2310                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2311                                         .channels = 8,
2312                                         .iface = 2,
2313                                         .altsetting = 1,
2314                                         .altset_idx = 1,
2315                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2316                                         .endpoint = 0x81,
2317                                         .ep_attr = 0x05,
2318                                         .rates = SNDRV_PCM_RATE_44100 |
2319                                                  SNDRV_PCM_RATE_48000 |
2320                                                  SNDRV_PCM_RATE_88200 |
2321                                                  SNDRV_PCM_RATE_96000,
2322                                         .rate_min = 44100,
2323                                         .rate_max = 96000,
2324                                         .nr_rates = 4,
2325                                         .rate_table = (unsigned int[]) {
2326                                                 44100, 48000, 88200, 96000
2327                                         }
2328                                 }
2329                         },
2330                         /* interface 3 (MIDI) is standard compliant */
2331                         {
2332                                 .ifnum = -1
2333                         }
2334                 }
2335         }
2336 },
2337 {
2338         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2339         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2340                 /* .vendor_name = "M-Audio", */
2341                 /* .product_name = "Fast Track Ultra 8R", */
2342                 .ifnum = QUIRK_ANY_INTERFACE,
2343                 .type = QUIRK_COMPOSITE,
2344                 .data = & (const struct snd_usb_audio_quirk[]) {
2345                         {
2346                                 .ifnum = 0,
2347                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2348                         },
2349                         {
2350                                 .ifnum = 1,
2351                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2352                                 .data = & (const struct audioformat) {
2353                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2354                                         .channels = 8,
2355                                         .iface = 1,
2356                                         .altsetting = 1,
2357                                         .altset_idx = 1,
2358                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2359                                         .endpoint = 0x01,
2360                                         .ep_attr = 0x09,
2361                                         .rates = SNDRV_PCM_RATE_44100 |
2362                                                  SNDRV_PCM_RATE_48000 |
2363                                                  SNDRV_PCM_RATE_88200 |
2364                                                  SNDRV_PCM_RATE_96000,
2365                                         .rate_min = 44100,
2366                                         .rate_max = 96000,
2367                                         .nr_rates = 4,
2368                                         .rate_table = (unsigned int[]) {
2369                                                         44100, 48000, 88200, 96000
2370                                         }
2371                                 }
2372                         },
2373                         {
2374                                 .ifnum = 2,
2375                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2376                                 .data = & (const struct audioformat) {
2377                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2378                                         .channels = 8,
2379                                         .iface = 2,
2380                                         .altsetting = 1,
2381                                         .altset_idx = 1,
2382                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2383                                         .endpoint = 0x81,
2384                                         .ep_attr = 0x05,
2385                                         .rates = SNDRV_PCM_RATE_44100 |
2386                                                  SNDRV_PCM_RATE_48000 |
2387                                                  SNDRV_PCM_RATE_88200 |
2388                                                  SNDRV_PCM_RATE_96000,
2389                                         .rate_min = 44100,
2390                                         .rate_max = 96000,
2391                                         .nr_rates = 4,
2392                                         .rate_table = (unsigned int[]) {
2393                                                 44100, 48000, 88200, 96000
2394                                         }
2395                                 }
2396                         },
2397                         /* interface 3 (MIDI) is standard compliant */
2398                         {
2399                                 .ifnum = -1
2400                         }
2401                 }
2402         }
2403 },
2404
2405 /* Casio devices */
2406 {
2407         USB_DEVICE(0x07cf, 0x6801),
2408         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2409                 .vendor_name = "Casio",
2410                 .product_name = "PL-40R",
2411                 .ifnum = 0,
2412                 .type = QUIRK_MIDI_YAMAHA
2413         }
2414 },
2415 {
2416         /* this ID is used by several devices without a product ID */
2417         USB_DEVICE(0x07cf, 0x6802),
2418         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2419                 .vendor_name = "Casio",
2420                 .product_name = "Keyboard",
2421                 .ifnum = 0,
2422                 .type = QUIRK_MIDI_YAMAHA
2423         }
2424 },
2425
2426 /* Mark of the Unicorn devices */
2427 {
2428         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2429         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2430                        USB_DEVICE_ID_MATCH_PRODUCT |
2431                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2432         .idVendor = 0x07fd,
2433         .idProduct = 0x0001,
2434         .bDeviceSubClass = 2,
2435         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2436                 .vendor_name = "MOTU",
2437                 .product_name = "Fastlane",
2438                 .ifnum = QUIRK_ANY_INTERFACE,
2439                 .type = QUIRK_COMPOSITE,
2440                 .data = & (const struct snd_usb_audio_quirk[]) {
2441                         {
2442                                 .ifnum = 0,
2443                                 .type = QUIRK_MIDI_RAW_BYTES
2444                         },
2445                         {
2446                                 .ifnum = 1,
2447                                 .type = QUIRK_IGNORE_INTERFACE
2448                         },
2449                         {
2450                                 .ifnum = -1
2451                         }
2452                 }
2453         }
2454 },
2455
2456 /* Emagic devices */
2457 {
2458         USB_DEVICE(0x086a, 0x0001),
2459         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2460                 .vendor_name = "Emagic",
2461                 /* .product_name = "Unitor8", */
2462                 .ifnum = 2,
2463                 .type = QUIRK_MIDI_EMAGIC,
2464                 .data = & (const struct snd_usb_midi_endpoint_info) {
2465                         .out_cables = 0x80ff,
2466                         .in_cables  = 0x80ff
2467                 }
2468         }
2469 },
2470 {
2471         USB_DEVICE(0x086a, 0x0002),
2472         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2473                 .vendor_name = "Emagic",
2474                 /* .product_name = "AMT8", */
2475                 .ifnum = 2,
2476                 .type = QUIRK_MIDI_EMAGIC,
2477                 .data = & (const struct snd_usb_midi_endpoint_info) {
2478                         .out_cables = 0x80ff,
2479                         .in_cables  = 0x80ff
2480                 }
2481         }
2482 },
2483 {
2484         USB_DEVICE(0x086a, 0x0003),
2485         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2486                 .vendor_name = "Emagic",
2487                 /* .product_name = "MT4", */
2488                 .ifnum = 2,
2489                 .type = QUIRK_MIDI_EMAGIC,
2490                 .data = & (const struct snd_usb_midi_endpoint_info) {
2491                         .out_cables = 0x800f,
2492                         .in_cables  = 0x8003
2493                 }
2494         }
2495 },
2496
2497 /* KORG devices */
2498 {
2499         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2500         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2501                 .vendor_name = "KORG, Inc.",
2502                 /* .product_name = "PANDORA PX5D", */
2503                 .ifnum = 3,
2504                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2505         }
2506 },
2507
2508 {
2509         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
2510         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2511                 .vendor_name = "KORG, Inc.",
2512                 /* .product_name = "ToneLab ST", */
2513                 .ifnum = 3,
2514                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2515         }
2516 },
2517
2518 /* AKAI devices */
2519 {
2520         USB_DEVICE(0x09e8, 0x0062),
2521         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2522                 .vendor_name = "AKAI",
2523                 .product_name = "MPD16",
2524                 .ifnum = 0,
2525                 .type = QUIRK_MIDI_AKAI,
2526         }
2527 },
2528
2529 /* TerraTec devices */
2530 {
2531         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2532         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2533                 .vendor_name = "TerraTec",
2534                 .product_name = "PHASE 26",
2535                 .ifnum = 3,
2536                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2537         }
2538 },
2539 {
2540         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2541         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2542                 .vendor_name = "TerraTec",
2543                 .product_name = "PHASE 26",
2544                 .ifnum = 3,
2545                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2546         }
2547 },
2548 {
2549         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2550         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2551                 .vendor_name = "TerraTec",
2552                 .product_name = "PHASE 26",
2553                 .ifnum = 3,
2554                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2555         }
2556 },
2557 {
2558         USB_DEVICE(0x0ccd, 0x0028),
2559         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2560                 .vendor_name = "TerraTec",
2561                 .product_name = "Aureon5.1MkII",
2562                 .ifnum = QUIRK_NO_INTERFACE
2563         }
2564 },
2565 {
2566         USB_DEVICE(0x0ccd, 0x0035),
2567         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2568                 .vendor_name = "Miditech",
2569                 .product_name = "Play'n Roll",
2570                 .ifnum = 0,
2571                 .type = QUIRK_MIDI_CME
2572         }
2573 },
2574
2575 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2576 {
2577         USB_DEVICE(0x103d, 0x0100),
2578                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2579                 .vendor_name = "Stanton",
2580                 .product_name = "ScratchAmp",
2581                 .ifnum = QUIRK_NO_INTERFACE
2582         }
2583 },
2584 {
2585         USB_DEVICE(0x103d, 0x0101),
2586                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2587                 .vendor_name = "Stanton",
2588                 .product_name = "ScratchAmp",
2589                 .ifnum = QUIRK_NO_INTERFACE
2590         }
2591 },
2592
2593 /* Novation EMS devices */
2594 {
2595         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2596         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2597                 .vendor_name = "Novation",
2598                 .product_name = "ReMOTE Audio/XStation",
2599                 .ifnum = 4,
2600                 .type = QUIRK_MIDI_NOVATION
2601         }
2602 },
2603 {
2604         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2605         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2606                 .vendor_name = "Novation",
2607                 .product_name = "Speedio",
2608                 .ifnum = 3,
2609                 .type = QUIRK_MIDI_NOVATION
2610         }
2611 },
2612 {
2613         USB_DEVICE(0x1235, 0x000e),
2614         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2615                 /* .vendor_name = "Novation", */
2616                 /* .product_name = "Launchpad", */
2617                 .ifnum = 0,
2618                 .type = QUIRK_MIDI_RAW_BYTES
2619         }
2620 },
2621 {
2622         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2623         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2624                 .vendor_name = "Novation",
2625                 .product_name = "ReMOTE25",
2626                 .ifnum = 0,
2627                 .type = QUIRK_MIDI_NOVATION
2628         }
2629 },
2630
2631 /* Access Music devices */
2632 {
2633         /* VirusTI Desktop */
2634         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2635         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2636                 .ifnum = QUIRK_ANY_INTERFACE,
2637                 .type = QUIRK_COMPOSITE,
2638                 .data = &(const struct snd_usb_audio_quirk[]) {
2639                         {
2640                                 .ifnum = 3,
2641                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2642                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2643                                         .out_cables = 0x0003,
2644                                         .in_cables  = 0x0003
2645                                 }
2646                         },
2647                         {
2648                                 .ifnum = 4,
2649                                 .type = QUIRK_IGNORE_INTERFACE
2650                         },
2651                         {
2652                                 .ifnum = -1
2653                         }
2654                 }
2655         }
2656 },
2657
2658 /* */
2659 {
2660         /* aka. Serato Scratch Live DJ Box */
2661         USB_DEVICE(0x13e5, 0x0001),
2662         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2663                 .vendor_name = "Rane",
2664                 .product_name = "SL-1",
2665                 .ifnum = QUIRK_NO_INTERFACE
2666         }
2667 },
2668
2669 /* Native Instruments MK2 series */
2670 {
2671         /* Komplete Audio 6 */
2672         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2673         .idVendor = 0x17cc,
2674         .idProduct = 0x1000,
2675 },
2676 {
2677         /* Traktor Audio 6 */
2678         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2679         .idVendor = 0x17cc,
2680         .idProduct = 0x1010,
2681 },
2682 {
2683         /* Traktor Audio 10 */
2684         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2685         .idVendor = 0x17cc,
2686         .idProduct = 0x1020,
2687 },
2688
2689 /* KeithMcMillen Stringport */
2690 {
2691         USB_DEVICE(0x1f38, 0x0001),
2692         .bInterfaceClass = USB_CLASS_AUDIO,
2693 },
2694
2695 /* Miditech devices */
2696 {
2697         USB_DEVICE(0x4752, 0x0011),
2698         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2699                 .vendor_name = "Miditech",
2700                 .product_name = "Midistart-2",
2701                 .ifnum = 0,
2702                 .type = QUIRK_MIDI_CME
2703         }
2704 },
2705
2706 /* Central Music devices */
2707 {
2708         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2709         USB_DEVICE(0x7104, 0x2202),
2710         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2711                 .ifnum = 0,
2712                 .type = QUIRK_MIDI_CME
2713         }
2714 },
2715
2716 /* Hauppauge HVR-950Q and HVR-850 */
2717 {
2718         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2719         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2720                        USB_DEVICE_ID_MATCH_INT_CLASS |
2721                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2722         .bInterfaceClass = USB_CLASS_AUDIO,
2723         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2724         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2725                 .vendor_name = "Hauppauge",
2726                 .product_name = "HVR-950Q",
2727                 .ifnum = QUIRK_ANY_INTERFACE,
2728                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2729         }
2730 },
2731 {
2732         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2733         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2734                        USB_DEVICE_ID_MATCH_INT_CLASS |
2735                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2736         .bInterfaceClass = USB_CLASS_AUDIO,
2737         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2738         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2739                 .vendor_name = "Hauppauge",
2740                 .product_name = "HVR-850",
2741                 .ifnum = QUIRK_ANY_INTERFACE,
2742                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2743         }
2744 },
2745 {
2746         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2747         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2748                        USB_DEVICE_ID_MATCH_INT_CLASS |
2749                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2750         .bInterfaceClass = USB_CLASS_AUDIO,
2751         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2752         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2753                 .vendor_name = "Hauppauge",
2754                 .product_name = "HVR-950Q",
2755                 .ifnum = QUIRK_ANY_INTERFACE,
2756                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2757         }
2758 },
2759 {
2760         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2761         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2762                        USB_DEVICE_ID_MATCH_INT_CLASS |
2763                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2764         .bInterfaceClass = USB_CLASS_AUDIO,
2765         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2766         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2767                 .vendor_name = "Hauppauge",
2768                 .product_name = "HVR-950Q",
2769                 .ifnum = QUIRK_ANY_INTERFACE,
2770                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2771         }
2772 },
2773 {
2774         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2775         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2776                        USB_DEVICE_ID_MATCH_INT_CLASS |
2777                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2778         .bInterfaceClass = USB_CLASS_AUDIO,
2779         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2780         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2781                 .vendor_name = "Hauppauge",
2782                 .product_name = "HVR-950Q",
2783                 .ifnum = QUIRK_ANY_INTERFACE,
2784                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2785         }
2786 },
2787 {
2788         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2789         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2790                        USB_DEVICE_ID_MATCH_INT_CLASS |
2791                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2792         .bInterfaceClass = USB_CLASS_AUDIO,
2793         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2794         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2795                 .vendor_name = "Hauppauge",
2796                 .product_name = "HVR-950Q",
2797                 .ifnum = QUIRK_ANY_INTERFACE,
2798                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2799         }
2800 },
2801 {
2802         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2803         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2804                        USB_DEVICE_ID_MATCH_INT_CLASS |
2805                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2806         .bInterfaceClass = USB_CLASS_AUDIO,
2807         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2808         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2809                 .vendor_name = "Hauppauge",
2810                 .product_name = "HVR-950Q",
2811                 .ifnum = QUIRK_ANY_INTERFACE,
2812                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2813         }
2814 },
2815 {
2816         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2817         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2818                        USB_DEVICE_ID_MATCH_INT_CLASS |
2819                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2820         .bInterfaceClass = USB_CLASS_AUDIO,
2821         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2822         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2823                 .vendor_name = "Hauppauge",
2824                 .product_name = "HVR-950Q",
2825                 .ifnum = QUIRK_ANY_INTERFACE,
2826                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2827         }
2828 },
2829 {
2830         USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2831         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2832                        USB_DEVICE_ID_MATCH_INT_CLASS |
2833                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2834         .bInterfaceClass = USB_CLASS_AUDIO,
2835         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2836         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2837                 .vendor_name = "Hauppauge",
2838                 .product_name = "HVR-950Q",
2839                 .ifnum = QUIRK_ANY_INTERFACE,
2840                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2841         }
2842 },
2843
2844 /* Digidesign Mbox */
2845 {
2846         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2847         USB_DEVICE(0x0dba, 0x1000),
2848         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2849                 .vendor_name = "Digidesign",
2850                 .product_name = "MBox",
2851                 .ifnum = QUIRK_ANY_INTERFACE,
2852                 .type = QUIRK_COMPOSITE,
2853                 .data = (const struct snd_usb_audio_quirk[]){
2854                         {
2855                                 .ifnum = 0,
2856                                 .type = QUIRK_IGNORE_INTERFACE,
2857                         },
2858                         {
2859                                 .ifnum = 1,
2860                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2861                                 .data = &(const struct audioformat) {
2862                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2863                                         .channels = 2,
2864                                         .iface = 1,
2865                                         .altsetting = 1,
2866                                         .altset_idx = 1,
2867                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2868                                         .endpoint = 0x02,
2869                                         .ep_attr = 0x01,
2870                                         .maxpacksize = 0x130,
2871                                         .rates = SNDRV_PCM_RATE_44100 |
2872                                                  SNDRV_PCM_RATE_48000,
2873                                         .rate_min = 44100,
2874                                         .rate_max = 48000,
2875                                         .nr_rates = 2,
2876                                         .rate_table = (unsigned int[]) {
2877                                                 44100, 48000
2878                                         }
2879                                 }
2880                         },
2881                         {
2882                                 .ifnum = -1
2883                         }
2884                 }
2885
2886         }
2887 },
2888 {
2889         /* Tascam US122 MKII - playback-only support */
2890         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2891         .idVendor = 0x0644,
2892         .idProduct = 0x8021,
2893         .bInterfaceClass = USB_CLASS_AUDIO,
2894         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2895                 .vendor_name = "TASCAM",
2896                 .product_name = "US122 MKII",
2897                 .ifnum = QUIRK_ANY_INTERFACE,
2898                 .type = QUIRK_COMPOSITE,
2899                 .data = (const struct snd_usb_audio_quirk[]) {
2900                         {
2901                                 .ifnum = 0,
2902                                 .type = QUIRK_IGNORE_INTERFACE
2903                         },
2904                         {
2905                                 .ifnum = 1,
2906                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2907                                 .data = &(const struct audioformat) {
2908                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2909                                         .channels = 2,
2910                                         .iface = 1,
2911                                         .altsetting = 1,
2912                                         .altset_idx = 1,
2913                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2914                                         .endpoint = 0x02,
2915                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2916                                         .rates = SNDRV_PCM_RATE_44100 |
2917                                                  SNDRV_PCM_RATE_48000 |
2918                                                  SNDRV_PCM_RATE_88200 |
2919                                                  SNDRV_PCM_RATE_96000,
2920                                         .rate_min = 44100,
2921                                         .rate_max = 96000,
2922                                         .nr_rates = 4,
2923                                         .rate_table = (unsigned int[]) {
2924                                                 44100, 48000, 88200, 96000
2925                                         }
2926                                 }
2927                         },
2928                         {
2929                                 .ifnum = -1
2930                         }
2931                 }
2932         }
2933 },
2934
2935 /* Microsoft XboxLive Headset/Xbox Communicator */
2936 {
2937         USB_DEVICE(0x045e, 0x0283),
2938         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2939         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2940                 .vendor_name = "Microsoft",
2941                 .product_name = "XboxLive Headset/Xbox Communicator",
2942                 .ifnum = QUIRK_ANY_INTERFACE,
2943                 .type = QUIRK_COMPOSITE,
2944                 .data = &(const struct snd_usb_audio_quirk[]) {
2945                         {
2946                                 /* playback */
2947                                 .ifnum = 0,
2948                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2949                                 .data = &(const struct audioformat) {
2950                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
2951                                         .channels = 1,
2952                                         .iface = 0,
2953                                         .altsetting = 0,
2954                                         .altset_idx = 0,
2955                                         .attributes = 0,
2956                                         .endpoint = 0x04,
2957                                         .ep_attr = 0x05,
2958                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
2959                                         .rate_min = 22050,
2960                                         .rate_max = 22050
2961                                 }
2962                         },
2963                         {
2964                                 /* capture */
2965                                 .ifnum = 1,
2966                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2967                                 .data = &(const struct audioformat) {
2968                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
2969                                         .channels = 1,
2970                                         .iface = 1,
2971                                         .altsetting = 0,
2972                                         .altset_idx = 0,
2973                                         .attributes = 0,
2974                                         .endpoint = 0x85,
2975                                         .ep_attr = 0x05,
2976                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
2977                                         .rate_min = 16000,
2978                                         .rate_max = 16000
2979                                 }
2980                         },
2981                         {
2982                                 .ifnum = -1
2983                         }
2984                 }
2985         }
2986 },
2987
2988 /* Reloop Play */
2989 {
2990         USB_DEVICE(0x200c, 0x100b),
2991         .bInterfaceClass = USB_CLASS_PER_INTERFACE,
2992         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2993                 .ifnum = QUIRK_ANY_INTERFACE,
2994                 .type = QUIRK_COMPOSITE,
2995                 .data = &(const struct snd_usb_audio_quirk[]) {
2996                         {
2997                                 .ifnum = 0,
2998                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2999                         },
3000                         {
3001                                 .ifnum = 1,
3002                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
3003                                 .data = &(const struct audioformat) {
3004                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
3005                                         .channels = 4,
3006                                         .iface = 1,
3007                                         .altsetting = 1,
3008                                         .altset_idx = 1,
3009                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
3010                                         .endpoint = 0x01,
3011                                         .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
3012                                         .rates = SNDRV_PCM_RATE_44100 |
3013                                                  SNDRV_PCM_RATE_48000,
3014                                         .rate_min = 44100,
3015                                         .rate_max = 48000,
3016                                         .nr_rates = 2,
3017                                         .rate_table = (unsigned int[]) {
3018                                                 44100, 48000
3019                                         }
3020                                 }
3021                         },
3022                         {
3023                                 .ifnum = -1
3024                         }
3025                 }
3026         }
3027 },
3028
3029 {
3030         /*
3031          * Focusrite Scarlett 18i6
3032          *
3033          * Avoid mixer creation, which otherwise fails because some of
3034          * the interface descriptor subtypes for interface 0 are
3035          * unknown.  That should be fixed or worked-around but this at
3036          * least allows the device to be used successfully with a DAW
3037          * and an external mixer.  See comments below about other
3038          * ignored interfaces.
3039          */
3040         USB_DEVICE(0x1235, 0x8004),
3041         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3042                 .vendor_name = "Focusrite",
3043                 .product_name = "Scarlett 18i6",
3044                 .ifnum = QUIRK_ANY_INTERFACE,
3045                 .type = QUIRK_COMPOSITE,
3046                 .data = & (const struct snd_usb_audio_quirk[]) {
3047                         {
3048                                 /* InterfaceSubClass 1 (Control Device) */
3049                                 .ifnum = 0,
3050                                 .type = QUIRK_IGNORE_INTERFACE
3051                         },
3052                         {
3053                                 .ifnum = 1,
3054                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3055                         },
3056                         {
3057                                 .ifnum = 2,
3058                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
3059                         },
3060                         {
3061                                 /* InterfaceSubClass 1 (Control Device) */
3062                                 .ifnum = 3,
3063                                 .type = QUIRK_IGNORE_INTERFACE
3064                         },
3065                         {
3066                                 .ifnum = 4,
3067                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3068                         },
3069                         {
3070                                 /* InterfaceSubClass 1 (Device Firmware Update) */
3071                                 .ifnum = 5,
3072                                 .type = QUIRK_IGNORE_INTERFACE
3073                         },
3074                         {
3075                                 .ifnum = -1
3076                         }
3077                 }
3078         }
3079 },
3080
3081 {
3082         /*
3083          * Some USB MIDI devices don't have an audio control interface,
3084          * so we have to grab MIDI streaming interfaces here.
3085          */
3086         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
3087                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
3088         .bInterfaceClass = USB_CLASS_AUDIO,
3089         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
3090         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
3091                 .ifnum = QUIRK_ANY_INTERFACE,
3092                 .type = QUIRK_MIDI_STANDARD_INTERFACE
3093         }
3094 },
3095
3096 #undef USB_DEVICE_VENDOR_SPEC