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 YAMAHA_DEVICE(0x2000, "DGP-7"),
 273 YAMAHA_DEVICE(0x2001, "DGP-5"),
 274 YAMAHA_DEVICE(0x2002, NULL),
 275 YAMAHA_DEVICE(0x2003, NULL),
 276 YAMAHA_DEVICE(0x5000, "CS1D"),
 277 YAMAHA_DEVICE(0x5001, "DSP1D"),
 278 YAMAHA_DEVICE(0x5002, "DME32"),
 279 YAMAHA_DEVICE(0x5003, "DM2000"),
 280 YAMAHA_DEVICE(0x5004, "02R96"),
 281 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 282 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 283 YAMAHA_DEVICE(0x5007, "DM1000"),
 284 YAMAHA_DEVICE(0x5008, "01V96"),
 285 YAMAHA_DEVICE(0x5009, "SPX2000"),
 286 YAMAHA_DEVICE(0x500a, "PM5D"),
 287 YAMAHA_DEVICE(0x500b, "DME64N"),
 288 YAMAHA_DEVICE(0x500c, "DME24N"),
 289 YAMAHA_DEVICE(0x500d, NULL),
 290 YAMAHA_DEVICE(0x500e, NULL),
 291 YAMAHA_DEVICE(0x500f, NULL),
 292 YAMAHA_DEVICE(0x7000, "DTX"),
 293 YAMAHA_DEVICE(0x7010, "UB99"),
 294 #undef YAMAHA_DEVICE
 295 #undef YAMAHA_INTERFACE
 296
 297 /*
 298  * Roland/RolandED/Edirol/BOSS devices
 299  */
 300 {
 301         USB_DEVICE(0x0582, 0x0000),
 302         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 303                 .vendor_name = "Roland",
 304                 .product_name = "UA-100",
 305                 .ifnum = QUIRK_ANY_INTERFACE,
 306                 .type = QUIRK_COMPOSITE,
 307                 .data = (const struct snd_usb_audio_quirk[]) {
 308                         {
 309                                 .ifnum = 0,
 310                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 311                                 .data = & (const struct audioformat) {
 312                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 313                                         .channels = 4,
 314                                         .iface = 0,
 315                                         .altsetting = 1,
 316                                         .altset_idx = 1,
 317                                         .attributes = 0,
 318                                         .endpoint = 0x01,
 319                                         .ep_attr = 0x09,
 320                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 321                                         .rate_min = 44100,
 322                                         .rate_max = 44100,
 323                                 }
 324                         },
 325                         {
 326                                 .ifnum = 1,
 327                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 328                                 .data = & (const struct audioformat) {
 329                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 330                                         .channels = 2,
 331                                         .iface = 1,
 332                                         .altsetting = 1,
 333                                         .altset_idx = 1,
 334                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX,
 335                                         .endpoint = 0x81,
 336                                         .ep_attr = 0x05,
 337                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 338                                         .rate_min = 44100,
 339                                         .rate_max = 44100,
 340                                 }
 341                         },
 342                         {
 343                                 .ifnum = 2,
 344                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 345                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 346                                         .out_cables = 0x0007,
 347                                         .in_cables  = 0x0007
 348                                 }
 349                         },
 350                         {
 351                                 .ifnum = -1
 352                         }
 353                 }
 354         }
 355 },
 356 {
 357         USB_DEVICE(0x0582, 0x0002),
 358         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 359                 .vendor_name = "EDIROL",
 360                 .product_name = "UM-4",
 361                 .ifnum = QUIRK_ANY_INTERFACE,
 362                 .type = QUIRK_COMPOSITE,
 363                 .data = (const struct snd_usb_audio_quirk[]) {
 364                         {
 365                                 .ifnum = 0,
 366                                 .type = QUIRK_IGNORE_INTERFACE
 367                         },
 368                         {
 369                                 .ifnum = 1,
 370                                 .type = QUIRK_IGNORE_INTERFACE
 371                         },
 372                         {
 373                                 .ifnum = 2,
 374                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 375                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 376                                         .out_cables = 0x000f,
 377                                         .in_cables  = 0x000f
 378                                 }
 379                         },
 380                         {
 381                                 .ifnum = -1
 382                         }
 383                 }
 384         }
 385 },
 386 {
 387         USB_DEVICE(0x0582, 0x0003),
 388         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 389                 .vendor_name = "Roland",
 390                 .product_name = "SC-8850",
 391                 .ifnum = QUIRK_ANY_INTERFACE,
 392                 .type = QUIRK_COMPOSITE,
 393                 .data = (const struct snd_usb_audio_quirk[]) {
 394                         {
 395                                 .ifnum = 0,
 396                                 .type = QUIRK_IGNORE_INTERFACE
 397                         },
 398                         {
 399                                 .ifnum = 1,
 400                                 .type = QUIRK_IGNORE_INTERFACE
 401                         },
 402                         {
 403                                 .ifnum = 2,
 404                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 405                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 406                                         .out_cables = 0x003f,
 407                                         .in_cables  = 0x003f
 408                                 }
 409                         },
 410                         {
 411                                 .ifnum = -1
 412                         }
 413                 }
 414         }
 415 },
 416 {
 417         USB_DEVICE(0x0582, 0x0004),
 418         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 419                 .vendor_name = "Roland",
 420                 .product_name = "U-8",
 421                 .ifnum = QUIRK_ANY_INTERFACE,
 422                 .type = QUIRK_COMPOSITE,
 423                 .data = (const struct snd_usb_audio_quirk[]) {
 424                         {
 425                                 .ifnum = 0,
 426                                 .type = QUIRK_IGNORE_INTERFACE
 427                         },
 428                         {
 429                                 .ifnum = 1,
 430                                 .type = QUIRK_IGNORE_INTERFACE
 431                         },
 432                         {
 433                                 .ifnum = 2,
 434                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 435                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 436                                         .out_cables = 0x0005,
 437                                         .in_cables  = 0x0005
 438                                 }
 439                         },
 440                         {
 441                                 .ifnum = -1
 442                         }
 443                 }
 444         }
 445 },
 446 {
 447         /* Has ID 0x0099 when not in "Advanced Driver" mode.
 448          * The UM-2EX has only one input, but we cannot detect this. */
 449         USB_DEVICE(0x0582, 0x0005),
 450         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 451                 .vendor_name = "EDIROL",
 452                 .product_name = "UM-2",
 453                 .ifnum = QUIRK_ANY_INTERFACE,
 454                 .type = QUIRK_COMPOSITE,
 455                 .data = (const struct snd_usb_audio_quirk[]) {
 456                         {
 457                                 .ifnum = 0,
 458                                 .type = QUIRK_IGNORE_INTERFACE
 459                         },
 460                         {
 461                                 .ifnum = 1,
 462                                 .type = QUIRK_IGNORE_INTERFACE
 463                         },
 464                         {
 465                                 .ifnum = 2,
 466                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 467                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 468                                         .out_cables = 0x0003,
 469                                         .in_cables  = 0x0003
 470                                 }
 471                         },
 472                         {
 473                                 .ifnum = -1
 474                         }
 475                 }
 476         }
 477 },
 478 {
 479         USB_DEVICE(0x0582, 0x0007),
 480         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 481                 .vendor_name = "Roland",
 482                 .product_name = "SC-8820",
 483                 .ifnum = QUIRK_ANY_INTERFACE,
 484                 .type = QUIRK_COMPOSITE,
 485                 .data = (const struct snd_usb_audio_quirk[]) {
 486                         {
 487                                 .ifnum = 0,
 488                                 .type = QUIRK_IGNORE_INTERFACE
 489                         },
 490                         {
 491                                 .ifnum = 1,
 492                                 .type = QUIRK_IGNORE_INTERFACE
 493                         },
 494                         {
 495                                 .ifnum = 2,
 496                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 497                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 498                                         .out_cables = 0x0013,
 499                                         .in_cables  = 0x0013
 500                                 }
 501                         },
 502                         {
 503                                 .ifnum = -1
 504                         }
 505                 }
 506         }
 507 },
 508 {
 509         USB_DEVICE(0x0582, 0x0008),
 510         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 511                 .vendor_name = "Roland",
 512                 .product_name = "PC-300",
 513                 .ifnum = QUIRK_ANY_INTERFACE,
 514                 .type = QUIRK_COMPOSITE,
 515                 .data = (const struct snd_usb_audio_quirk[]) {
 516                         {
 517                                 .ifnum = 0,
 518                                 .type = QUIRK_IGNORE_INTERFACE
 519                         },
 520                         {
 521                                 .ifnum = 1,
 522                                 .type = QUIRK_IGNORE_INTERFACE
 523                         },
 524                         {
 525                                 .ifnum = 2,
 526                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 527                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 528                                         .out_cables = 0x0001,
 529                                         .in_cables  = 0x0001
 530                                 }
 531                         },
 532                         {
 533                                 .ifnum = -1
 534                         }
 535                 }
 536         }
 537 },
 538 {
 539         /* has ID 0x009d when not in "Advanced Driver" mode */
 540         USB_DEVICE(0x0582, 0x0009),
 541         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 542                 .vendor_name = "EDIROL",
 543                 .product_name = "UM-1",
 544                 .ifnum = QUIRK_ANY_INTERFACE,
 545                 .type = QUIRK_COMPOSITE,
 546                 .data = (const struct snd_usb_audio_quirk[]) {
 547                         {
 548                                 .ifnum = 0,
 549                                 .type = QUIRK_IGNORE_INTERFACE
 550                         },
 551                         {
 552                                 .ifnum = 1,
 553                                 .type = QUIRK_IGNORE_INTERFACE
 554                         },
 555                         {
 556                                 .ifnum = 2,
 557                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 558                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 559                                         .out_cables = 0x0001,
 560                                         .in_cables  = 0x0001
 561                                 }
 562                         },
 563                         {
 564                                 .ifnum = -1
 565                         }
 566                 }
 567         }
 568 },
 569 {
 570         USB_DEVICE(0x0582, 0x000b),
 571         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 572                 .vendor_name = "Roland",
 573                 .product_name = "SK-500",
 574                 .ifnum = QUIRK_ANY_INTERFACE,
 575                 .type = QUIRK_COMPOSITE,
 576                 .data = (const struct snd_usb_audio_quirk[]) {
 577                         {
 578                                 .ifnum = 0,
 579                                 .type = QUIRK_IGNORE_INTERFACE
 580                         },
 581                         {
 582                                 .ifnum = 1,
 583                                 .type = QUIRK_IGNORE_INTERFACE
 584                         },
 585                         {
 586                                 .ifnum = 2,
 587                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 588                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 589                                         .out_cables = 0x0013,
 590                                         .in_cables  = 0x0013
 591                                 }
 592                         },
 593                         {
 594                                 .ifnum = -1
 595                         }
 596                 }
 597         }
 598 },
 599 {
 600         /* thanks to Emiliano Grilli <emillo@libero.it>
 601          * for helping researching this data */
 602         USB_DEVICE(0x0582, 0x000c),
 603         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 604                 .vendor_name = "Roland",
 605                 .product_name = "SC-D70",
 606                 .ifnum = QUIRK_ANY_INTERFACE,
 607                 .type = QUIRK_COMPOSITE,
 608                 .data = (const struct snd_usb_audio_quirk[]) {
 609                         {
 610                                 .ifnum = 0,
 611                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 612                                 .data = & (const struct audioformat) {
 613                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 614                                         .channels = 2,
 615                                         .iface = 0,
 616                                         .altsetting = 1,
 617                                         .altset_idx = 1,
 618                                         .attributes = 0,
 619                                         .endpoint = 0x01,
 620                                         .ep_attr = 0x01,
 621                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 622                                         .rate_min = 44100,
 623                                         .rate_max = 44100,
 624                                 }
 625                         },
 626                         {
 627                                 .ifnum = 1,
 628                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 629                                 .data = & (const struct audioformat) {
 630                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 631                                         .channels = 2,
 632                                         .iface = 1,
 633                                         .altsetting = 1,
 634                                         .altset_idx = 1,
 635                                         .attributes = 0,
 636                                         .endpoint = 0x81,
 637                                         .ep_attr = 0x01,
 638                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 639                                         .rate_min = 44100,
 640                                         .rate_max = 44100,
 641                                 }
 642                         },
 643                         {
 644                                 .ifnum = 2,
 645                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 646                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 647                                         .out_cables = 0x0007,
 648                                         .in_cables  = 0x0007
 649                                 }
 650                         },
 651                         {
 652                                 .ifnum = -1
 653                         }
 654                 }
 655         }
 656 },
 657 {       /*
 658          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 659          * If the advanced mode switch at the back of the unit is off, the
 660          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 661          * but offers only 16-bit PCM.
 662          * In advanced mode, the UA-5 will output S24_3LE samples (two
 663          * channels) at the rate indicated on the front switch, including
 664          * the 96kHz sample rate.
 665          */
 666         USB_DEVICE(0x0582, 0x0010),
 667         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 668                 .vendor_name = "EDIROL",
 669                 .product_name = "UA-5",
 670                 .ifnum = QUIRK_ANY_INTERFACE,
 671                 .type = QUIRK_COMPOSITE,
 672                 .data = (const struct snd_usb_audio_quirk[]) {
 673                         {
 674                                 .ifnum = 1,
 675                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 676                         },
 677                         {
 678                                 .ifnum = 2,
 679                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 680                         },
 681                         {
 682                                 .ifnum = -1
 683                         }
 684                 }
 685         }
 686 },
 687 {
 688         /* has ID 0x0013 when not in "Advanced Driver" mode */
 689         USB_DEVICE(0x0582, 0x0012),
 690         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 691                 .vendor_name = "Roland",
 692                 .product_name = "XV-5050",
 693                 .ifnum = 0,
 694                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 695                 .data = & (const struct snd_usb_midi_endpoint_info) {
 696                         .out_cables = 0x0001,
 697                         .in_cables  = 0x0001
 698                 }
 699         }
 700 },
 701 {
 702         /* has ID 0x0015 when not in "Advanced Driver" mode */
 703         USB_DEVICE(0x0582, 0x0014),
 704         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 705                 .vendor_name = "EDIROL",
 706                 .product_name = "UM-880",
 707                 .ifnum = 0,
 708                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 709                 .data = & (const struct snd_usb_midi_endpoint_info) {
 710                         .out_cables = 0x01ff,
 711                         .in_cables  = 0x01ff
 712                 }
 713         }
 714 },
 715 {
 716         /* has ID 0x0017 when not in "Advanced Driver" mode */
 717         USB_DEVICE(0x0582, 0x0016),
 718         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 719                 .vendor_name = "EDIROL",
 720                 .product_name = "SD-90",
 721                 .ifnum = QUIRK_ANY_INTERFACE,
 722                 .type = QUIRK_COMPOSITE,
 723                 .data = (const struct snd_usb_audio_quirk[]) {
 724                         {
 725                                 .ifnum = 0,
 726                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 727                         },
 728                         {
 729                                 .ifnum = 1,
 730                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 731                         },
 732                         {
 733                                 .ifnum = 2,
 734                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 735                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 736                                         .out_cables = 0x000f,
 737                                         .in_cables  = 0x000f
 738                                 }
 739                         },
 740                         {
 741                                 .ifnum = -1
 742                         }
 743                 }
 744         }
 745 },
 746 {
 747         /* has ID 0x001c when not in "Advanced Driver" mode */
 748         USB_DEVICE(0x0582, 0x001b),
 749         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 750                 .vendor_name = "Roland",
 751                 .product_name = "MMP-2",
 752                 .ifnum = QUIRK_ANY_INTERFACE,
 753                 .type = QUIRK_COMPOSITE,
 754                 .data = (const struct snd_usb_audio_quirk[]) {
 755                         {
 756                                 .ifnum = 0,
 757                                 .type = QUIRK_IGNORE_INTERFACE
 758                         },
 759                         {
 760                                 .ifnum = 1,
 761                                 .type = QUIRK_IGNORE_INTERFACE
 762                         },
 763                         {
 764                                 .ifnum = 2,
 765                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 766                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 767                                         .out_cables = 0x0001,
 768                                         .in_cables  = 0x0001
 769                                 }
 770                         },
 771                         {
 772                                 .ifnum = -1
 773                         }
 774                 }
 775         }
 776 },
 777 {
 778         /* has ID 0x001e when not in "Advanced Driver" mode */
 779         USB_DEVICE(0x0582, 0x001d),
 780         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 781                 .vendor_name = "Roland",
 782                 .product_name = "V-SYNTH",
 783                 .ifnum = 0,
 784                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 785                 .data = & (const struct snd_usb_midi_endpoint_info) {
 786                         .out_cables = 0x0001,
 787                         .in_cables  = 0x0001
 788                 }
 789         }
 790 },
 791 {
 792         /* has ID 0x0024 when not in "Advanced Driver" mode */
 793         USB_DEVICE(0x0582, 0x0023),
 794         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 795                 .vendor_name = "EDIROL",
 796                 .product_name = "UM-550",
 797                 .ifnum = 0,
 798                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 799                 .data = & (const struct snd_usb_midi_endpoint_info) {
 800                         .out_cables = 0x003f,
 801                         .in_cables  = 0x003f
 802                 }
 803         }
 804 },
 805 {
 806         /*
 807          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 808          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 809          * and no MIDI.
 810          */
 811         USB_DEVICE(0x0582, 0x0025),
 812         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 813                 .vendor_name = "EDIROL",
 814                 .product_name = "UA-20",
 815                 .ifnum = QUIRK_ANY_INTERFACE,
 816                 .type = QUIRK_COMPOSITE,
 817                 .data = (const struct snd_usb_audio_quirk[]) {
 818                         {
 819                                 .ifnum = 0,
 820                                 .type = QUIRK_IGNORE_INTERFACE
 821                         },
 822                         {
 823                                 .ifnum = 1,
 824                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 825                                 .data = & (const struct audioformat) {
 826                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 827                                         .channels = 2,
 828                                         .iface = 1,
 829                                         .altsetting = 1,
 830                                         .altset_idx = 1,
 831                                         .attributes = 0,
 832                                         .endpoint = 0x01,
 833                                         .ep_attr = 0x01,
 834                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 835                                         .rate_min = 44100,
 836                                         .rate_max = 44100,
 837                                 }
 838                         },
 839                         {
 840                                 .ifnum = 2,
 841                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 842                                 .data = & (const struct audioformat) {
 843                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
 844                                         .channels = 2,
 845                                         .iface = 2,
 846                                         .altsetting = 1,
 847                                         .altset_idx = 1,
 848                                         .attributes = 0,
 849                                         .endpoint = 0x82,
 850                                         .ep_attr = 0x01,
 851                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 852                                         .rate_min = 44100,
 853                                         .rate_max = 44100,
 854                                 }
 855                         },
 856                         {
 857                                 .ifnum = 3,
 858                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 859                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 860                                         .out_cables = 0x0001,
 861                                         .in_cables  = 0x0001
 862                                 }
 863                         },
 864                         {
 865                                 .ifnum = -1
 866                         }
 867                 }
 868         }
 869 },
 870 {
 871         /* has ID 0x0028 when not in "Advanced Driver" mode */
 872         USB_DEVICE(0x0582, 0x0027),
 873         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 874                 .vendor_name = "EDIROL",
 875                 .product_name = "SD-20",
 876                 .ifnum = 0,
 877                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 878                 .data = & (const struct snd_usb_midi_endpoint_info) {
 879                         .out_cables = 0x0003,
 880                         .in_cables  = 0x0007
 881                 }
 882         }
 883 },
 884 {
 885         /* has ID 0x002a when not in "Advanced Driver" mode */
 886         USB_DEVICE(0x0582, 0x0029),
 887         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 888                 .vendor_name = "EDIROL",
 889                 .product_name = "SD-80",
 890                 .ifnum = 0,
 891                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 892                 .data = & (const struct snd_usb_midi_endpoint_info) {
 893                         .out_cables = 0x000f,
 894                         .in_cables  = 0x000f
 895                 }
 896         }
 897 },
 898 {       /*
 899          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 900          * If the sample format switch is not in an advanced setting, the
 901          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 902          * but offers only 16-bit PCM and no MIDI.
 903          */
 904         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 905         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 906                 .vendor_name = "EDIROL",
 907                 .product_name = "UA-700",
 908                 .ifnum = QUIRK_ANY_INTERFACE,
 909                 .type = QUIRK_COMPOSITE,
 910                 .data = (const struct snd_usb_audio_quirk[]) {
 911                         {
 912                                 .ifnum = 1,
 913                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 914                         },
 915                         {
 916                                 .ifnum = 2,
 917                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 918                         },
 919                         {
 920                                 .ifnum = 3,
 921                                 .type = QUIRK_AUDIO_EDIROL_UAXX
 922                         },
 923                         {
 924                                 .ifnum = -1
 925                         }
 926                 }
 927         }
 928 },
 929 {
 930         /* has ID 0x002e when not in "Advanced Driver" mode */
 931         USB_DEVICE(0x0582, 0x002d),
 932         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 933                 .vendor_name = "Roland",
 934                 .product_name = "XV-2020",
 935                 .ifnum = 0,
 936                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 937                 .data = & (const struct snd_usb_midi_endpoint_info) {
 938                         .out_cables = 0x0001,
 939                         .in_cables  = 0x0001
 940                 }
 941         }
 942 },
 943 {
 944         /* has ID 0x0030 when not in "Advanced Driver" mode */
 945         USB_DEVICE(0x0582, 0x002f),
 946         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 947                 .vendor_name = "Roland",
 948                 .product_name = "VariOS",
 949                 .ifnum = 0,
 950                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 951                 .data = & (const struct snd_usb_midi_endpoint_info) {
 952                         .out_cables = 0x0007,
 953                         .in_cables  = 0x0007
 954                 }
 955         }
 956 },
 957 {
 958         /* has ID 0x0034 when not in "Advanced Driver" mode */
 959         USB_DEVICE(0x0582, 0x0033),
 960         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 961                 .vendor_name = "EDIROL",
 962                 .product_name = "PCR",
 963                 .ifnum = 0,
 964                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 965                 .data = & (const struct snd_usb_midi_endpoint_info) {
 966                         .out_cables = 0x0003,
 967                         .in_cables  = 0x0007
 968                 }
 969         }
 970 },
 971         /* TODO: add Roland M-1000 support */
 972 {
 973         /*
 974          * Has ID 0x0038 when not in "Advanced Driver" mode;
 975          * later revisions use IDs 0x0054 and 0x00a2.
 976          */
 977         USB_DEVICE(0x0582, 0x0037),
 978         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 979                 .vendor_name = "Roland",
 980                 .product_name = "Digital Piano",
 981                 .ifnum = 0,
 982                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 983                 .data = & (const struct snd_usb_midi_endpoint_info) {
 984                         .out_cables = 0x0001,
 985                         .in_cables  = 0x0001
 986                 }
 987         }
 988 },
 989 {
 990         /*
 991          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
 992          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
 993          * and no MIDI.
 994          */
 995         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 996         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 997                 .vendor_name = "BOSS",
 998                 .product_name = "GS-10",
 999                 .ifnum = QUIRK_ANY_INTERFACE,
1000                 .type = QUIRK_COMPOSITE,
1001                 .data = & (const struct snd_usb_audio_quirk[]) {
1002                         {
1003                                 .ifnum = 1,
1004                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1005                         },
1006                         {
1007                                 .ifnum = 2,
1008                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1009                         },
1010                         {
1011                                 .ifnum = 3,
1012                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1013                         },
1014                         {
1015                                 .ifnum = -1
1016                         }
1017                 }
1018         }
1019 },
1020 {
1021         /* has ID 0x0041 when not in "Advanced Driver" mode */
1022         USB_DEVICE(0x0582, 0x0040),
1023         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1024                 .vendor_name = "Roland",
1025                 .product_name = "GI-20",
1026                 .ifnum = 0,
1027                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1028                 .data = & (const struct snd_usb_midi_endpoint_info) {
1029                         .out_cables = 0x0001,
1030                         .in_cables  = 0x0001
1031                 }
1032         }
1033 },
1034 {
1035         /* has ID 0x0043 when not in "Advanced Driver" mode */
1036         USB_DEVICE(0x0582, 0x0042),
1037         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1038                 .vendor_name = "Roland",
1039                 .product_name = "RS-70",
1040                 .ifnum = 0,
1041                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1042                 .data = & (const struct snd_usb_midi_endpoint_info) {
1043                         .out_cables = 0x0001,
1044                         .in_cables  = 0x0001
1045                 }
1046         }
1047 },
1048 {
1049         /* has ID 0x0049 when not in "Advanced Driver" mode */
1050         USB_DEVICE(0x0582, 0x0047),
1051         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1052                 /* .vendor_name = "EDIROL", */
1053                 /* .product_name = "UR-80", */
1054                 .ifnum = QUIRK_ANY_INTERFACE,
1055                 .type = QUIRK_COMPOSITE,
1056                 .data = (const struct snd_usb_audio_quirk[]) {
1057                         /* in the 96 kHz modes, only interface 1 is there */
1058                         {
1059                                 .ifnum = 1,
1060                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1061                         },
1062                         {
1063                                 .ifnum = 2,
1064                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1065                         },
1066                         {
1067                                 .ifnum = -1
1068                         }
1069                 }
1070         }
1071 },
1072 {
1073         /* has ID 0x004a when not in "Advanced Driver" mode */
1074         USB_DEVICE(0x0582, 0x0048),
1075         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1076                 /* .vendor_name = "EDIROL", */
1077                 /* .product_name = "UR-80", */
1078                 .ifnum = 0,
1079                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1080                 .data = & (const struct snd_usb_midi_endpoint_info) {
1081                         .out_cables = 0x0003,
1082                         .in_cables  = 0x0007
1083                 }
1084         }
1085 },
1086         /* TODO: add Edirol M-100FX support */
1087 {
1088         /* has ID 0x004e when not in "Advanced Driver" mode */
1089         USB_DEVICE(0x0582, 0x004c),
1090         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1091                 .vendor_name = "EDIROL",
1092                 .product_name = "PCR-A",
1093                 .ifnum = QUIRK_ANY_INTERFACE,
1094                 .type = QUIRK_COMPOSITE,
1095                 .data = (const struct snd_usb_audio_quirk[]) {
1096                         {
1097                                 .ifnum = 1,
1098                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1099                         },
1100                         {
1101                                 .ifnum = 2,
1102                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1103                         },
1104                         {
1105                                 .ifnum = -1
1106                         }
1107                 }
1108         }
1109 },
1110 {
1111         /* has ID 0x004f when not in "Advanced Driver" mode */
1112         USB_DEVICE(0x0582, 0x004d),
1113         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1114                 .vendor_name = "EDIROL",
1115                 .product_name = "PCR-A",
1116                 .ifnum = 0,
1117                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1118                 .data = & (const struct snd_usb_midi_endpoint_info) {
1119                         .out_cables = 0x0003,
1120                         .in_cables  = 0x0007
1121                 }
1122         }
1123 },
1124 {
1125         /*
1126          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
1127          * is standard compliant, but has only 16-bit PCM.
1128          */
1129         USB_DEVICE(0x0582, 0x0050),
1130         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1131                 .vendor_name = "EDIROL",
1132                 .product_name = "UA-3FX",
1133                 .ifnum = QUIRK_ANY_INTERFACE,
1134                 .type = QUIRK_COMPOSITE,
1135                 .data = (const struct snd_usb_audio_quirk[]) {
1136                         {
1137                                 .ifnum = 1,
1138                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1139                         },
1140                         {
1141                                 .ifnum = 2,
1142                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1143                         },
1144                         {
1145                                 .ifnum = -1
1146                         }
1147                 }
1148         }
1149 },
1150 {
1151         USB_DEVICE(0x0582, 0x0052),
1152         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1153                 .vendor_name = "EDIROL",
1154                 .product_name = "UM-1SX",
1155                 .ifnum = 0,
1156                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1157         }
1158 },
1159 {
1160         USB_DEVICE(0x0582, 0x0060),
1161         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1162                 .vendor_name = "Roland",
1163                 .product_name = "EXR Series",
1164                 .ifnum = 0,
1165                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1166         }
1167 },
1168 {
1169         /* has ID 0x0066 when not in "Advanced Driver" mode */
1170         USB_DEVICE(0x0582, 0x0064),
1171         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1172                 /* .vendor_name = "EDIROL", */
1173                 /* .product_name = "PCR-1", */
1174                 .ifnum = QUIRK_ANY_INTERFACE,
1175                 .type = QUIRK_COMPOSITE,
1176                 .data = (const struct snd_usb_audio_quirk[]) {
1177                         {
1178                                 .ifnum = 1,
1179                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1180                         },
1181                         {
1182                                 .ifnum = 2,
1183                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1184                         },
1185                         {
1186                                 .ifnum = -1
1187                         }
1188                 }
1189         }
1190 },
1191 {
1192         /* has ID 0x0067 when not in "Advanced Driver" mode */
1193         USB_DEVICE(0x0582, 0x0065),
1194         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1195                 /* .vendor_name = "EDIROL", */
1196                 /* .product_name = "PCR-1", */
1197                 .ifnum = 0,
1198                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1199                 .data = & (const struct snd_usb_midi_endpoint_info) {
1200                         .out_cables = 0x0001,
1201                         .in_cables  = 0x0003
1202                 }
1203         }
1204 },
1205 {
1206         /* has ID 0x006b when not in "Advanced Driver" mode */
1207         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1208         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1209                 .vendor_name = "Roland",
1210                 .product_name = "SP-606",
1211                 .ifnum = 3,
1212                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1213                 .data = & (const struct snd_usb_midi_endpoint_info) {
1214                         .out_cables = 0x0001,
1215                         .in_cables  = 0x0001
1216                 }
1217         }
1218 },
1219 {
1220         /* has ID 0x006e when not in "Advanced Driver" mode */
1221         USB_DEVICE(0x0582, 0x006d),
1222         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1223                 .vendor_name = "Roland",
1224                 .product_name = "FANTOM-X",
1225                 .ifnum = 0,
1226                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1227                 .data = & (const struct snd_usb_midi_endpoint_info) {
1228                         .out_cables = 0x0001,
1229                         .in_cables  = 0x0001
1230                 }
1231         }
1232 },
1233 {       /*
1234          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1235          * If the switch is not in an advanced setting, the UA-25 has
1236          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1237          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1238          */
1239         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1240         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1241                 .vendor_name = "EDIROL",
1242                 .product_name = "UA-25",
1243                 .ifnum = QUIRK_ANY_INTERFACE,
1244                 .type = QUIRK_COMPOSITE,
1245                 .data = (const struct snd_usb_audio_quirk[]) {
1246                         {
1247                                 .ifnum = 0,
1248                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1249                         },
1250                         {
1251                                 .ifnum = 1,
1252                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1253                         },
1254                         {
1255                                 .ifnum = 2,
1256                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1257                         },
1258                         {
1259                                 .ifnum = -1
1260                         }
1261                 }
1262         }
1263 },
1264 {
1265         /* has ID 0x0076 when not in "Advanced Driver" mode */
1266         USB_DEVICE(0x0582, 0x0075),
1267         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1268                 .vendor_name = "BOSS",
1269                 .product_name = "DR-880",
1270                 .ifnum = 0,
1271                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1272                 .data = & (const struct snd_usb_midi_endpoint_info) {
1273                         .out_cables = 0x0001,
1274                         .in_cables  = 0x0001
1275                 }
1276         }
1277 },
1278 {
1279         /* has ID 0x007b when not in "Advanced Driver" mode */
1280         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1281         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1282                 .vendor_name = "Roland",
1283                 /* "RD" or "RD-700SX"? */
1284                 .ifnum = 0,
1285                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1286                 .data = & (const struct snd_usb_midi_endpoint_info) {
1287                         .out_cables = 0x0003,
1288                         .in_cables  = 0x0003
1289                 }
1290         }
1291 },
1292 {
1293         /* has ID 0x0081 when not in "Advanced Driver" mode */
1294         USB_DEVICE(0x0582, 0x0080),
1295         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1296                 .vendor_name = "Roland",
1297                 .product_name = "G-70",
1298                 .ifnum = 0,
1299                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1300                 .data = & (const struct snd_usb_midi_endpoint_info) {
1301                         .out_cables = 0x0001,
1302                         .in_cables  = 0x0001
1303                 }
1304         }
1305 },
1306         /* TODO: add Roland V-SYNTH XT support */
1307         /* TODO: add BOSS GT-PRO support */
1308 {
1309         /* has ID 0x008c when not in "Advanced Driver" mode */
1310         USB_DEVICE(0x0582, 0x008b),
1311         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1312                 .vendor_name = "EDIROL",
1313                 .product_name = "PC-50",
1314                 .ifnum = 0,
1315                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1316                 .data = & (const struct snd_usb_midi_endpoint_info) {
1317                         .out_cables = 0x0001,
1318                         .in_cables  = 0x0001
1319                 }
1320         }
1321 },
1322         /* TODO: add Edirol PC-80 support */
1323 {
1324         USB_DEVICE(0x0582, 0x0096),
1325         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1326                 .vendor_name = "EDIROL",
1327                 .product_name = "UA-1EX",
1328                 .ifnum = QUIRK_ANY_INTERFACE,
1329                 .type = QUIRK_COMPOSITE,
1330                 .data = (const struct snd_usb_audio_quirk[]) {
1331                         {
1332                                 .ifnum = 0,
1333                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1334                         },
1335                         {
1336                                 .ifnum = 1,
1337                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1338                         },
1339                         {
1340                                 .ifnum = -1
1341                         }
1342                 }
1343         }
1344 },
1345 {
1346         USB_DEVICE(0x0582, 0x009a),
1347         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1348                 .vendor_name = "EDIROL",
1349                 .product_name = "UM-3EX",
1350                 .ifnum = 0,
1351                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1352                 .data = & (const struct snd_usb_midi_endpoint_info) {
1353                         .out_cables = 0x000f,
1354                         .in_cables  = 0x000f
1355                 }
1356         }
1357 },
1358 {
1359         /*
1360          * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
1361          * is standard compliant, but has only 16-bit PCM and no MIDI.
1362          */
1363         USB_DEVICE(0x0582, 0x00a3),
1364         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1365                 .vendor_name = "EDIROL",
1366                 .product_name = "UA-4FX",
1367                 .ifnum = QUIRK_ANY_INTERFACE,
1368                 .type = QUIRK_COMPOSITE,
1369                 .data = (const struct snd_usb_audio_quirk[]) {
1370                         {
1371                                 .ifnum = 0,
1372                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1373                         },
1374                         {
1375                                 .ifnum = 1,
1376                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1377                         },
1378                         {
1379                                 .ifnum = 2,
1380                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1381                         },
1382                         {
1383                                 .ifnum = -1
1384                         }
1385                 }
1386         }
1387 },
1388         /* TODO: add Edirol MD-P1 support */
1389 {
1390         USB_DEVICE(0x582, 0x00a6),
1391         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1392                 .vendor_name = "Roland",
1393                 .product_name = "Juno-G",
1394                 .ifnum = 0,
1395                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1396                 .data = & (const struct snd_usb_midi_endpoint_info) {
1397                         .out_cables = 0x0001,
1398                         .in_cables  = 0x0001
1399                 }
1400         }
1401 },
1402 {
1403         /* Roland SH-201 */
1404         USB_DEVICE(0x0582, 0x00ad),
1405         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1406                 .vendor_name = "Roland",
1407                 .product_name = "SH-201",
1408                 .ifnum = QUIRK_ANY_INTERFACE,
1409                 .type = QUIRK_COMPOSITE,
1410                 .data = (const struct snd_usb_audio_quirk[]) {
1411                         {
1412                                 .ifnum = 0,
1413                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1414                         },
1415                         {
1416                                 .ifnum = 1,
1417                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1418                         },
1419                         {
1420                                 .ifnum = 2,
1421                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1422                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1423                                         .out_cables = 0x0001,
1424                                         .in_cables  = 0x0001
1425                                 }
1426                         },
1427                         {
1428                                 .ifnum = -1
1429                         }
1430                 }
1431         }
1432 },
1433 {
1434         /* Roland SonicCell */
1435         USB_DEVICE(0x0582, 0x00c2),
1436         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1437                 .vendor_name = "Roland",
1438                 .product_name = "SonicCell",
1439                 .ifnum = QUIRK_ANY_INTERFACE,
1440                 .type = QUIRK_COMPOSITE,
1441                 .data = (const struct snd_usb_audio_quirk[]) {
1442                         {
1443                                 .ifnum = 0,
1444                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1445                         },
1446                         {
1447                                 .ifnum = 1,
1448                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1449                         },
1450                         {
1451                                 .ifnum = 2,
1452                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1453                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1454                                         .out_cables = 0x0001,
1455                                         .in_cables  = 0x0001
1456                                 }
1457                         },
1458                         {
1459                                 .ifnum = -1
1460                         }
1461                 }
1462         }
1463 },
1464 {
1465         /* Edirol M-16DX */
1466         /* FIXME: This quirk gives a good-working capture stream but the
1467          *        playback seems problematic because of lacking of sync
1468          *        with capture stream.  It needs to sync with the capture
1469          *        clock.  As now, you'll get frequent sound distortions
1470          *        via the playback.
1471          */
1472         USB_DEVICE(0x0582, 0x00c4),
1473         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1474                 .ifnum = QUIRK_ANY_INTERFACE,
1475                 .type = QUIRK_COMPOSITE,
1476                 .data = (const struct snd_usb_audio_quirk[]) {
1477                         {
1478                                 .ifnum = 0,
1479                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1480                         },
1481                         {
1482                                 .ifnum = 1,
1483                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1484                         },
1485                         {
1486                                 .ifnum = 2,
1487                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1488                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1489                                         .out_cables = 0x0001,
1490                                         .in_cables  = 0x0001
1491                                 }
1492                         },
1493                         {
1494                                 .ifnum = -1
1495                         }
1496                 }
1497         }
1498 },
1499 {
1500         /* BOSS GT-10 */
1501         USB_DEVICE(0x0582, 0x00da),
1502         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1503                 .ifnum = QUIRK_ANY_INTERFACE,
1504                 .type = QUIRK_COMPOSITE,
1505                 .data = (const struct snd_usb_audio_quirk[]) {
1506                         {
1507                                 .ifnum = 0,
1508                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1509                         },
1510                         {
1511                                 .ifnum = 1,
1512                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1513                         },
1514                         {
1515                                 .ifnum = 2,
1516                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1517                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1518                                         .out_cables = 0x0001,
1519                                         .in_cables  = 0x0001
1520                                 }
1521                         },
1522                         {
1523                                 .ifnum = -1
1524                         }
1525                 }
1526         }
1527 },
1528 {
1529         /* Advanced modes of the Edirol UA-25EX.
1530          * For the standard mode, UA-25EX has ID 0582:00e7, which
1531          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1532          */
1533         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
1534         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1535                 .vendor_name = "EDIROL",
1536                 .product_name = "UA-25EX",
1537                 .ifnum = QUIRK_ANY_INTERFACE,
1538                 .type = QUIRK_COMPOSITE,
1539                 .data = (const struct snd_usb_audio_quirk[]) {
1540                         {
1541                                 .ifnum = 0,
1542                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1543                         },
1544                         {
1545                                 .ifnum = 1,
1546                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1547                         },
1548                         {
1549                                 .ifnum = 2,
1550                                 .type = QUIRK_AUDIO_EDIROL_UAXX
1551                         },
1552                         {
1553                                 .ifnum = -1
1554                         }
1555                 }
1556         }
1557 },
1558 {
1559         /* has ID 0x00ea when not in Advanced Driver mode */
1560         USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9),
1561         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1562                 /* .vendor_name = "Roland", */
1563                 /* .product_name = "UA-1G", */
1564                 .ifnum = QUIRK_ANY_INTERFACE,
1565                 .type = QUIRK_COMPOSITE,
1566                 .data = (const struct snd_usb_audio_quirk[]) {
1567                         {
1568                                 .ifnum = 0,
1569                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1570                         },
1571                         {
1572                                 .ifnum = 1,
1573                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1574                         },
1575                         {
1576                                 .ifnum = -1
1577                         }
1578                 }
1579         }
1580 },
1581 {
1582         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104),
1583         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1584                 /* .vendor_name = "Roland", */
1585                 /* .product_name = "UM-1G", */
1586                 .ifnum = 0,
1587                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1588                 .data = & (const struct snd_usb_midi_endpoint_info) {
1589                         .out_cables = 0x0001,
1590                         .in_cables  = 0x0001
1591                 }
1592         }
1593 },
1594 {
1595         /* Boss JS-8 Jam Station  */
1596         USB_DEVICE(0x0582, 0x0109),
1597         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1598                 /* .vendor_name = "BOSS", */
1599                 /* .product_name = "JS-8", */
1600                 .ifnum = QUIRK_ANY_INTERFACE,
1601                 .type = QUIRK_COMPOSITE,
1602                 .data = (const struct snd_usb_audio_quirk[]) {
1603                         {
1604                                 .ifnum = 0,
1605                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1606                         },
1607                         {
1608                                 .ifnum = 1,
1609                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1610                         },
1611                         {
1612                                 .ifnum = 2,
1613                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1614                         },
1615                         {
1616                                 .ifnum = -1
1617                         }
1618                 }
1619         }
1620 },
1621 {
1622         /* has ID 0x0110 when not in Advanced Driver mode */
1623         USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f),
1624         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1625                 /* .vendor_name = "Roland", */
1626                 /* .product_name = "A-PRO", */
1627                 .ifnum = 1,
1628                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1629                 .data = & (const struct snd_usb_midi_endpoint_info) {
1630                         .out_cables = 0x0003,
1631                         .in_cables  = 0x0007
1632                 }
1633         }
1634 },
1635 {
1636         /* Roland GAIA SH-01 */
1637         USB_DEVICE(0x0582, 0x0111),
1638         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
1639                 .vendor_name = "Roland",
1640                 .product_name = "GAIA",
1641                 .ifnum = QUIRK_ANY_INTERFACE,
1642                 .type = QUIRK_COMPOSITE,
1643                 .data = (const struct snd_usb_audio_quirk[]) {
1644                         {
1645                                 .ifnum = 0,
1646                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1647                         },
1648                         {
1649                                 .ifnum = 1,
1650                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1651                         },
1652                         {
1653                                 .ifnum = 2,
1654                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1655                                 .data = &(const struct snd_usb_midi_endpoint_info) {
1656                                 .out_cables = 0x0003,
1657                                 .in_cables  = 0x0003
1658                                 }
1659                         },
1660                         {
1661                                 .ifnum = -1
1662                         }
1663                 }
1664         }
1665 },
1666 {
1667         USB_DEVICE(0x0582, 0x0113),
1668         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1669                 /* .vendor_name = "BOSS", */
1670                 /* .product_name = "ME-25", */
1671                 .ifnum = QUIRK_ANY_INTERFACE,
1672                 .type = QUIRK_COMPOSITE,
1673                 .data = (const struct snd_usb_audio_quirk[]) {
1674                         {
1675                                 .ifnum = 0,
1676                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1677                         },
1678                         {
1679                                 .ifnum = 1,
1680                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1681                         },
1682                         {
1683                                 .ifnum = 2,
1684                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1685                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1686                                         .out_cables = 0x0001,
1687                                         .in_cables  = 0x0001
1688                                 }
1689                         },
1690                         {
1691                                 .ifnum = -1
1692                         }
1693                 }
1694         }
1695 },
1696 {
1697         USB_DEVICE(0x0582, 0x0127),
1698         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1699                 /* .vendor_name = "Roland", */
1700                 /* .product_name = "GR-55", */
1701                 .ifnum = QUIRK_ANY_INTERFACE,
1702                 .type = QUIRK_COMPOSITE,
1703                 .data = (const struct snd_usb_audio_quirk[]) {
1704                         {
1705                                 .ifnum = 0,
1706                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1707                         },
1708                         {
1709                                 .ifnum = 1,
1710                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1711                         },
1712                         {
1713                                 .ifnum = 2,
1714                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1715                         },
1716                         {
1717                                 .ifnum = -1
1718                         }
1719                 }
1720         }
1721 },
1722 {
1723         /* Added support for Roland UM-ONE which differs from UM-1 */
1724         USB_DEVICE(0x0582, 0x012a),
1725         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1726                 /* .vendor_name = "ROLAND", */
1727                 /* .product_name = "UM-ONE", */
1728                 .ifnum = 0,
1729                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1730                 .data = & (const struct snd_usb_midi_endpoint_info) {
1731                         .out_cables = 0x0001,
1732                         .in_cables  = 0x0003
1733                 }
1734         }
1735 },
1736 {
1737         USB_DEVICE(0x0582, 0x011e),
1738         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1739                 /* .vendor_name = "BOSS", */
1740                 /* .product_name = "BR-800", */
1741                 .ifnum = QUIRK_ANY_INTERFACE,
1742                 .type = QUIRK_COMPOSITE,
1743                 .data = (const struct snd_usb_audio_quirk[]) {
1744                         {
1745                                 .ifnum = 0,
1746                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1747                         },
1748                         {
1749                                 .ifnum = 1,
1750                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1751                         },
1752                         {
1753                                 .ifnum = 2,
1754                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1755                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1756                                         .out_cables = 0x0001,
1757                                         .in_cables  = 0x0001
1758                                 }
1759                         },
1760                         {
1761                                 .ifnum = -1
1762                         }
1763                 }
1764         }
1765 },
1766 {
1767         USB_DEVICE(0x0582, 0x0130),
1768         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1769                 /* .vendor_name = "BOSS", */
1770                 /* .product_name = "MICRO BR-80", */
1771                 .ifnum = QUIRK_ANY_INTERFACE,
1772                 .type = QUIRK_COMPOSITE,
1773                 .data = (const struct snd_usb_audio_quirk[]) {
1774                         {
1775                                 .ifnum = 0,
1776                                 .type = QUIRK_IGNORE_INTERFACE
1777                         },
1778                         {
1779                                 .ifnum = 1,
1780                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1781                         },
1782                         {
1783                                 .ifnum = 2,
1784                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1785                         },
1786                         {
1787                                 .ifnum = 3,
1788                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1789                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1790                                         .out_cables = 0x0001,
1791                                         .in_cables  = 0x0001
1792                                 }
1793                         },
1794                         {
1795                                 .ifnum = -1
1796                         }
1797                 }
1798         }
1799 },
1800
1801 /* Guillemot devices */
1802 {
1803         /*
1804          * This is for the "Windows Edition" where the external MIDI ports are
1805          * the only MIDI ports; the control data is reported through HID
1806          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1807          * compliant USB MIDI ports for external MIDI and controls.
1808          */
1809         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1810         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1811                 .vendor_name = "Hercules",
1812                 .product_name = "DJ Console (WE)",
1813                 .ifnum = 4,
1814                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1815                 .data = & (const struct snd_usb_midi_endpoint_info) {
1816                         .out_cables = 0x0001,
1817                         .in_cables = 0x0001
1818                 }
1819         }
1820 },
1821
1822 /* Midiman/M-Audio devices */
1823 {
1824         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1825         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1826                 .vendor_name = "M-Audio",
1827                 .product_name = "MidiSport 2x2",
1828                 .ifnum = QUIRK_ANY_INTERFACE,
1829                 .type = QUIRK_MIDI_MIDIMAN,
1830                 .data = & (const struct snd_usb_midi_endpoint_info) {
1831                         .out_cables = 0x0003,
1832                         .in_cables  = 0x0003
1833                 }
1834         }
1835 },
1836 {
1837         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1838         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1839                 .vendor_name = "M-Audio",
1840                 .product_name = "MidiSport 1x1",
1841                 .ifnum = QUIRK_ANY_INTERFACE,
1842                 .type = QUIRK_MIDI_MIDIMAN,
1843                 .data = & (const struct snd_usb_midi_endpoint_info) {
1844                         .out_cables = 0x0001,
1845                         .in_cables  = 0x0001
1846                 }
1847         }
1848 },
1849 {
1850         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1851         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1852                 .vendor_name = "M-Audio",
1853                 .product_name = "Keystation",
1854                 .ifnum = QUIRK_ANY_INTERFACE,
1855                 .type = QUIRK_MIDI_MIDIMAN,
1856                 .data = & (const struct snd_usb_midi_endpoint_info) {
1857                         .out_cables = 0x0001,
1858                         .in_cables  = 0x0001
1859                 }
1860         }
1861 },
1862 {
1863         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1864         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1865                 .vendor_name = "M-Audio",
1866                 .product_name = "MidiSport 4x4",
1867                 .ifnum = QUIRK_ANY_INTERFACE,
1868                 .type = QUIRK_MIDI_MIDIMAN,
1869                 .data = & (const struct snd_usb_midi_endpoint_info) {
1870                         .out_cables = 0x000f,
1871                         .in_cables  = 0x000f
1872                 }
1873         }
1874 },
1875 {
1876         /*
1877          * For hardware revision 1.05; in the later revisions (1.10 and
1878          * 1.21), 0x1031 is the ID for the device without firmware.
1879          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1880          */
1881         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1882         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1883                 .vendor_name = "M-Audio",
1884                 .product_name = "MidiSport 8x8",
1885                 .ifnum = QUIRK_ANY_INTERFACE,
1886                 .type = QUIRK_MIDI_MIDIMAN,
1887                 .data = & (const struct snd_usb_midi_endpoint_info) {
1888                         .out_cables = 0x01ff,
1889                         .in_cables  = 0x01ff
1890                 }
1891         }
1892 },
1893 {
1894         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1895         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1896                 .vendor_name = "M-Audio",
1897                 .product_name = "MidiSport 8x8",
1898                 .ifnum = QUIRK_ANY_INTERFACE,
1899                 .type = QUIRK_MIDI_MIDIMAN,
1900                 .data = & (const struct snd_usb_midi_endpoint_info) {
1901                         .out_cables = 0x01ff,
1902                         .in_cables  = 0x01ff
1903                 }
1904         }
1905 },
1906 {
1907         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1908         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1909                 .vendor_name = "M-Audio",
1910                 .product_name = "MidiSport 2x4",
1911                 .ifnum = QUIRK_ANY_INTERFACE,
1912                 .type = QUIRK_MIDI_MIDIMAN,
1913                 .data = & (const struct snd_usb_midi_endpoint_info) {
1914                         .out_cables = 0x000f,
1915                         .in_cables  = 0x0003
1916                 }
1917         }
1918 },
1919 {
1920         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1921         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1922                 .vendor_name = "M-Audio",
1923                 .product_name = "Quattro",
1924                 .ifnum = QUIRK_ANY_INTERFACE,
1925                 .type = QUIRK_COMPOSITE,
1926                 .data = & (const struct snd_usb_audio_quirk[]) {
1927                         /*
1928                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1929                          * and share endpoints with the other interfaces.
1930                          * Ignore them.  The other interfaces can do 24 bits,
1931                          * but captured samples are big-endian (see usbaudio.c).
1932                          */
1933                         {
1934                                 .ifnum = 0,
1935                                 .type = QUIRK_IGNORE_INTERFACE
1936                         },
1937                         {
1938                                 .ifnum = 1,
1939                                 .type = QUIRK_IGNORE_INTERFACE
1940                         },
1941                         {
1942                                 .ifnum = 2,
1943                                 .type = QUIRK_IGNORE_INTERFACE
1944                         },
1945                         {
1946                                 .ifnum = 3,
1947                                 .type = QUIRK_IGNORE_INTERFACE
1948                         },
1949                         {
1950                                 .ifnum = 4,
1951                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1952                         },
1953                         {
1954                                 .ifnum = 5,
1955                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1956                         },
1957                         {
1958                                 .ifnum = 6,
1959                                 .type = QUIRK_IGNORE_INTERFACE
1960                         },
1961                         {
1962                                 .ifnum = 7,
1963                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1964                         },
1965                         {
1966                                 .ifnum = 8,
1967                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1968                         },
1969                         {
1970                                 .ifnum = 9,
1971                                 .type = QUIRK_MIDI_MIDIMAN,
1972                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1973                                         .out_cables = 0x0001,
1974                                         .in_cables  = 0x0001
1975                                 }
1976                         },
1977                         {
1978                                 .ifnum = -1
1979                         }
1980                 }
1981         }
1982 },
1983 {
1984         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1985         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1986                 .vendor_name = "M-Audio",
1987                 .product_name = "AudioPhile",
1988                 .ifnum = 6,
1989                 .type = QUIRK_MIDI_MIDIMAN,
1990                 .data = & (const struct snd_usb_midi_endpoint_info) {
1991                         .out_cables = 0x0001,
1992                         .in_cables  = 0x0001
1993                 }
1994         }
1995 },
1996 {
1997         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1998         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1999                 .vendor_name = "M-Audio",
2000                 .product_name = "Ozone",
2001                 .ifnum = 3,
2002                 .type = QUIRK_MIDI_MIDIMAN,
2003                 .data = & (const struct snd_usb_midi_endpoint_info) {
2004                         .out_cables = 0x0001,
2005                         .in_cables  = 0x0001
2006                 }
2007         }
2008 },
2009 {
2010         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2011         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2012                 .vendor_name = "M-Audio",
2013                 .product_name = "OmniStudio",
2014                 .ifnum = QUIRK_ANY_INTERFACE,
2015                 .type = QUIRK_COMPOSITE,
2016                 .data = & (const struct snd_usb_audio_quirk[]) {
2017                         {
2018                                 .ifnum = 0,
2019                                 .type = QUIRK_IGNORE_INTERFACE
2020                         },
2021                         {
2022                                 .ifnum = 1,
2023                                 .type = QUIRK_IGNORE_INTERFACE
2024                         },
2025                         {
2026                                 .ifnum = 2,
2027                                 .type = QUIRK_IGNORE_INTERFACE
2028                         },
2029                         {
2030                                 .ifnum = 3,
2031                                 .type = QUIRK_IGNORE_INTERFACE
2032                         },
2033                         {
2034                                 .ifnum = 4,
2035                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2036                         },
2037                         {
2038                                 .ifnum = 5,
2039                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2040                         },
2041                         {
2042                                 .ifnum = 6,
2043                                 .type = QUIRK_IGNORE_INTERFACE
2044                         },
2045                         {
2046                                 .ifnum = 7,
2047                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2048                         },
2049                         {
2050                                 .ifnum = 8,
2051                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2052                         },
2053                         {
2054                                 .ifnum = 9,
2055                                 .type = QUIRK_MIDI_MIDIMAN,
2056                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2057                                         .out_cables = 0x0001,
2058                                         .in_cables  = 0x0001
2059                                 }
2060                         },
2061                         {
2062                                 .ifnum = -1
2063                         }
2064                 }
2065         }
2066 },
2067 {
2068         USB_DEVICE(0x0763, 0x2019),
2069         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2070                 /* .vendor_name = "M-Audio", */
2071                 /* .product_name = "Ozone Academic", */
2072                 .ifnum = QUIRK_ANY_INTERFACE,
2073                 .type = QUIRK_COMPOSITE,
2074                 .data = & (const struct snd_usb_audio_quirk[]) {
2075                         {
2076                                 .ifnum = 0,
2077                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2078                         },
2079                         {
2080                                 .ifnum = 1,
2081                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2082                         },
2083                         {
2084                                 .ifnum = 2,
2085                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2086                         },
2087                         {
2088                                 .ifnum = 3,
2089                                 .type = QUIRK_MIDI_MIDIMAN,
2090                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2091                                         .out_cables = 0x0001,
2092                                         .in_cables  = 0x0001
2093                                 }
2094                         },
2095                         {
2096                                 .ifnum = -1
2097                         }
2098                 }
2099         }
2100 },
2101 {
2102         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2103         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2104                 /* .vendor_name = "M-Audio", */
2105                 /* .product_name = "Fast Track Ultra", */
2106                 .ifnum = QUIRK_ANY_INTERFACE,
2107                 .type = QUIRK_COMPOSITE,
2108                 .data = & (const struct snd_usb_audio_quirk[]) {
2109                         {
2110                                 .ifnum = 0,
2111                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2112                         },
2113                         {
2114                                 .ifnum = 1,
2115                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2116                                 .data = & (const struct audioformat) {
2117                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2118                                         .channels = 8,
2119                                         .iface = 1,
2120                                         .altsetting = 1,
2121                                         .altset_idx = 1,
2122                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2123                                         .endpoint = 0x01,
2124                                         .ep_attr = 0x09,
2125                                         .rates = SNDRV_PCM_RATE_44100 |
2126                                                  SNDRV_PCM_RATE_48000 |
2127                                                  SNDRV_PCM_RATE_88200 |
2128                                                  SNDRV_PCM_RATE_96000,
2129                                         .rate_min = 44100,
2130                                         .rate_max = 96000,
2131                                         .nr_rates = 4,
2132                                         .rate_table = (unsigned int[]) {
2133                                                 44100, 48000, 88200, 96000
2134                                         }
2135                                 }
2136                         },
2137                         {
2138                                 .ifnum = 2,
2139                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2140                                 .data = & (const struct audioformat) {
2141                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2142                                         .channels = 8,
2143                                         .iface = 2,
2144                                         .altsetting = 1,
2145                                         .altset_idx = 1,
2146                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2147                                         .endpoint = 0x81,
2148                                         .ep_attr = 0x05,
2149                                         .rates = SNDRV_PCM_RATE_44100 |
2150                                                  SNDRV_PCM_RATE_48000 |
2151                                                  SNDRV_PCM_RATE_88200 |
2152                                                  SNDRV_PCM_RATE_96000,
2153                                         .rate_min = 44100,
2154                                         .rate_max = 96000,
2155                                         .nr_rates = 4,
2156                                         .rate_table = (unsigned int[]) {
2157                                                 44100, 48000, 88200, 96000
2158                                         }
2159                                 }
2160                         },
2161                         /* interface 3 (MIDI) is standard compliant */
2162                         {
2163                                 .ifnum = -1
2164                         }
2165                 }
2166         }
2167 },
2168 {
2169         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2170         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2171                 /* .vendor_name = "M-Audio", */
2172                 /* .product_name = "Fast Track Ultra 8R", */
2173                 .ifnum = QUIRK_ANY_INTERFACE,
2174                 .type = QUIRK_COMPOSITE,
2175                 .data = & (const struct snd_usb_audio_quirk[]) {
2176                         {
2177                                 .ifnum = 0,
2178                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2179                         },
2180                         {
2181                                 .ifnum = 1,
2182                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2183                                 .data = & (const struct audioformat) {
2184                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2185                                         .channels = 8,
2186                                         .iface = 1,
2187                                         .altsetting = 1,
2188                                         .altset_idx = 1,
2189                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2190                                         .endpoint = 0x01,
2191                                         .ep_attr = 0x09,
2192                                         .rates = SNDRV_PCM_RATE_44100 |
2193                                                  SNDRV_PCM_RATE_48000 |
2194                                                  SNDRV_PCM_RATE_88200 |
2195                                                  SNDRV_PCM_RATE_96000,
2196                                         .rate_min = 44100,
2197                                         .rate_max = 96000,
2198                                         .nr_rates = 4,
2199                                         .rate_table = (unsigned int[]) {
2200                                                         44100, 48000, 88200, 96000
2201                                         }
2202                                 }
2203                         },
2204                         {
2205                                 .ifnum = 2,
2206                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2207                                 .data = & (const struct audioformat) {
2208                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2209                                         .channels = 8,
2210                                         .iface = 2,
2211                                         .altsetting = 1,
2212                                         .altset_idx = 1,
2213                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2214                                         .endpoint = 0x81,
2215                                         .ep_attr = 0x05,
2216                                         .rates = SNDRV_PCM_RATE_44100 |
2217                                                  SNDRV_PCM_RATE_48000 |
2218                                                  SNDRV_PCM_RATE_88200 |
2219                                                  SNDRV_PCM_RATE_96000,
2220                                         .rate_min = 44100,
2221                                         .rate_max = 96000,
2222                                         .nr_rates = 4,
2223                                         .rate_table = (unsigned int[]) {
2224                                                 44100, 48000, 88200, 96000
2225                                         }
2226                                 }
2227                         },
2228                         /* interface 3 (MIDI) is standard compliant */
2229                         {
2230                                 .ifnum = -1
2231                         }
2232                 }
2233         }
2234 },
2235
2236 /* Casio devices */
2237 {
2238         USB_DEVICE(0x07cf, 0x6801),
2239         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2240                 .vendor_name = "Casio",
2241                 .product_name = "PL-40R",
2242                 .ifnum = 0,
2243                 .type = QUIRK_MIDI_YAMAHA
2244         }
2245 },
2246 {
2247         /* this ID is used by several devices without a product ID */
2248         USB_DEVICE(0x07cf, 0x6802),
2249         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2250                 .vendor_name = "Casio",
2251                 .product_name = "Keyboard",
2252                 .ifnum = 0,
2253                 .type = QUIRK_MIDI_YAMAHA
2254         }
2255 },
2256
2257 /* Mark of the Unicorn devices */
2258 {
2259         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2260         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2261                        USB_DEVICE_ID_MATCH_PRODUCT |
2262                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2263         .idVendor = 0x07fd,
2264         .idProduct = 0x0001,
2265         .bDeviceSubClass = 2,
2266         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2267                 .vendor_name = "MOTU",
2268                 .product_name = "Fastlane",
2269                 .ifnum = QUIRK_ANY_INTERFACE,
2270                 .type = QUIRK_COMPOSITE,
2271                 .data = & (const struct snd_usb_audio_quirk[]) {
2272                         {
2273                                 .ifnum = 0,
2274                                 .type = QUIRK_MIDI_RAW_BYTES
2275                         },
2276                         {
2277                                 .ifnum = 1,
2278                                 .type = QUIRK_IGNORE_INTERFACE
2279                         },
2280                         {
2281                                 .ifnum = -1
2282                         }
2283                 }
2284         }
2285 },
2286
2287 /* Emagic devices */
2288 {
2289         USB_DEVICE(0x086a, 0x0001),
2290         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2291                 .vendor_name = "Emagic",
2292                 /* .product_name = "Unitor8", */
2293                 .ifnum = 2,
2294                 .type = QUIRK_MIDI_EMAGIC,
2295                 .data = & (const struct snd_usb_midi_endpoint_info) {
2296                         .out_cables = 0x80ff,
2297                         .in_cables  = 0x80ff
2298                 }
2299         }
2300 },
2301 {
2302         USB_DEVICE(0x086a, 0x0002),
2303         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2304                 .vendor_name = "Emagic",
2305                 /* .product_name = "AMT8", */
2306                 .ifnum = 2,
2307                 .type = QUIRK_MIDI_EMAGIC,
2308                 .data = & (const struct snd_usb_midi_endpoint_info) {
2309                         .out_cables = 0x80ff,
2310                         .in_cables  = 0x80ff
2311                 }
2312         }
2313 },
2314 {
2315         USB_DEVICE(0x086a, 0x0003),
2316         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2317                 .vendor_name = "Emagic",
2318                 /* .product_name = "MT4", */
2319                 .ifnum = 2,
2320                 .type = QUIRK_MIDI_EMAGIC,
2321                 .data = & (const struct snd_usb_midi_endpoint_info) {
2322                         .out_cables = 0x800f,
2323                         .in_cables  = 0x8003
2324                 }
2325         }
2326 },
2327
2328 /* KORG devices */
2329 {
2330         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2331         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2332                 .vendor_name = "KORG, Inc.",
2333                 /* .product_name = "PANDORA PX5D", */
2334                 .ifnum = 3,
2335                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2336         }
2337 },
2338
2339 /* AKAI devices */
2340 {
2341         USB_DEVICE(0x09e8, 0x0062),
2342         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2343                 .vendor_name = "AKAI",
2344                 .product_name = "MPD16",
2345                 .ifnum = 0,
2346                 .type = QUIRK_MIDI_AKAI,
2347         }
2348 },
2349
2350 /* TerraTec devices */
2351 {
2352         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2353         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2354                 .vendor_name = "TerraTec",
2355                 .product_name = "PHASE 26",
2356                 .ifnum = 3,
2357                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2358         }
2359 },
2360 {
2361         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2362         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2363                 .vendor_name = "TerraTec",
2364                 .product_name = "PHASE 26",
2365                 .ifnum = 3,
2366                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2367         }
2368 },
2369 {
2370         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2371         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2372                 .vendor_name = "TerraTec",
2373                 .product_name = "PHASE 26",
2374                 .ifnum = 3,
2375                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2376         }
2377 },
2378 {
2379         USB_DEVICE(0x0ccd, 0x0028),
2380         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2381                 .vendor_name = "TerraTec",
2382                 .product_name = "Aureon5.1MkII",
2383                 .ifnum = QUIRK_NO_INTERFACE
2384         }
2385 },
2386 {
2387         USB_DEVICE(0x0ccd, 0x0035),
2388         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2389                 .vendor_name = "Miditech",
2390                 .product_name = "Play'n Roll",
2391                 .ifnum = 0,
2392                 .type = QUIRK_MIDI_CME
2393         }
2394 },
2395
2396 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2397 {
2398         USB_DEVICE(0x103d, 0x0100),
2399                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2400                 .vendor_name = "Stanton",
2401                 .product_name = "ScratchAmp",
2402                 .ifnum = QUIRK_NO_INTERFACE
2403         }
2404 },
2405 {
2406         USB_DEVICE(0x103d, 0x0101),
2407                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2408                 .vendor_name = "Stanton",
2409                 .product_name = "ScratchAmp",
2410                 .ifnum = QUIRK_NO_INTERFACE
2411         }
2412 },
2413
2414 /* Novation EMS devices */
2415 {
2416         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2417         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2418                 .vendor_name = "Novation",
2419                 .product_name = "ReMOTE Audio/XStation",
2420                 .ifnum = 4,
2421                 .type = QUIRK_MIDI_NOVATION
2422         }
2423 },
2424 {
2425         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2426         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2427                 .vendor_name = "Novation",
2428                 .product_name = "Speedio",
2429                 .ifnum = 3,
2430                 .type = QUIRK_MIDI_NOVATION
2431         }
2432 },
2433 {
2434         USB_DEVICE(0x1235, 0x000e),
2435         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2436                 /* .vendor_name = "Novation", */
2437                 /* .product_name = "Launchpad", */
2438                 .ifnum = 0,
2439                 .type = QUIRK_MIDI_RAW_BYTES
2440         }
2441 },
2442 {
2443         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2444         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2445                 .vendor_name = "Novation",
2446                 .product_name = "ReMOTE25",
2447                 .ifnum = 0,
2448                 .type = QUIRK_MIDI_NOVATION
2449         }
2450 },
2451
2452 /* Access Music devices */
2453 {
2454         /* VirusTI Desktop */
2455         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2456         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2457                 .ifnum = QUIRK_ANY_INTERFACE,
2458                 .type = QUIRK_COMPOSITE,
2459                 .data = &(const struct snd_usb_audio_quirk[]) {
2460                         {
2461                                 .ifnum = 3,
2462                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2463                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2464                                         .out_cables = 0x0003,
2465                                         .in_cables  = 0x0003
2466                                 }
2467                         },
2468                         {
2469                                 .ifnum = 4,
2470                                 .type = QUIRK_IGNORE_INTERFACE
2471                         },
2472                         {
2473                                 .ifnum = -1
2474                         }
2475                 }
2476         }
2477 },
2478
2479 /* */
2480 {
2481         /* aka. Serato Scratch Live DJ Box */
2482         USB_DEVICE(0x13e5, 0x0001),
2483         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2484                 .vendor_name = "Rane",
2485                 .product_name = "SL-1",
2486                 .ifnum = QUIRK_NO_INTERFACE
2487         }
2488 },
2489
2490 /* Native Instruments MK2 series */
2491 {
2492         /* Komplete Audio 6 */
2493         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2494         .idVendor = 0x17cc,
2495         .idProduct = 0x1000,
2496 },
2497 {
2498         /* Traktor Audio 6 */
2499         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2500         .idVendor = 0x17cc,
2501         .idProduct = 0x1010,
2502 },
2503 {
2504         /* Traktor Audio 10 */
2505         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2506         .idVendor = 0x17cc,
2507         .idProduct = 0x1020,
2508 },
2509
2510 /* KeithMcMillen Stringport */
2511 {
2512         USB_DEVICE(0x1f38, 0x0001),
2513         .bInterfaceClass = USB_CLASS_AUDIO,
2514 },
2515
2516 /* Miditech devices */
2517 {
2518         USB_DEVICE(0x4752, 0x0011),
2519         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2520                 .vendor_name = "Miditech",
2521                 .product_name = "Midistart-2",
2522                 .ifnum = 0,
2523                 .type = QUIRK_MIDI_CME
2524         }
2525 },
2526
2527 /* Central Music devices */
2528 {
2529         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2530         USB_DEVICE(0x7104, 0x2202),
2531         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2532                 .ifnum = 0,
2533                 .type = QUIRK_MIDI_CME
2534         }
2535 },
2536
2537 /* Hauppauge HVR-950Q and HVR-850 */
2538 {
2539         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200),
2540         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2541                        USB_DEVICE_ID_MATCH_INT_CLASS |
2542                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2543         .bInterfaceClass = USB_CLASS_AUDIO,
2544         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2545         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2546                 .vendor_name = "Hauppauge",
2547                 .product_name = "HVR-950Q",
2548                 .ifnum = QUIRK_ANY_INTERFACE,
2549                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2550         }
2551 },
2552 {
2553         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240),
2554         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2555                        USB_DEVICE_ID_MATCH_INT_CLASS |
2556                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2557         .bInterfaceClass = USB_CLASS_AUDIO,
2558         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2559         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2560                 .vendor_name = "Hauppauge",
2561                 .product_name = "HVR-850",
2562                 .ifnum = QUIRK_ANY_INTERFACE,
2563                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2564         }
2565 },
2566 {
2567         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210),
2568         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2569                        USB_DEVICE_ID_MATCH_INT_CLASS |
2570                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2571         .bInterfaceClass = USB_CLASS_AUDIO,
2572         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2573         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2574                 .vendor_name = "Hauppauge",
2575                 .product_name = "HVR-950Q",
2576                 .ifnum = QUIRK_ANY_INTERFACE,
2577                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2578         }
2579 },
2580 {
2581         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217),
2582         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2583                        USB_DEVICE_ID_MATCH_INT_CLASS |
2584                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2585         .bInterfaceClass = USB_CLASS_AUDIO,
2586         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2587         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2588                 .vendor_name = "Hauppauge",
2589                 .product_name = "HVR-950Q",
2590                 .ifnum = QUIRK_ANY_INTERFACE,
2591                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2592         }
2593 },
2594 {
2595         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b),
2596         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2597                        USB_DEVICE_ID_MATCH_INT_CLASS |
2598                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2599         .bInterfaceClass = USB_CLASS_AUDIO,
2600         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2601         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2602                 .vendor_name = "Hauppauge",
2603                 .product_name = "HVR-950Q",
2604                 .ifnum = QUIRK_ANY_INTERFACE,
2605                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2606         }
2607 },
2608 {
2609         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e),
2610         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2611                        USB_DEVICE_ID_MATCH_INT_CLASS |
2612                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2613         .bInterfaceClass = USB_CLASS_AUDIO,
2614         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2615         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2616                 .vendor_name = "Hauppauge",
2617                 .product_name = "HVR-950Q",
2618                 .ifnum = QUIRK_ANY_INTERFACE,
2619                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2620         }
2621 },
2622 {
2623         USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f),
2624         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2625                        USB_DEVICE_ID_MATCH_INT_CLASS |
2626                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2627         .bInterfaceClass = USB_CLASS_AUDIO,
2628         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2629         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2630                 .vendor_name = "Hauppauge",
2631                 .product_name = "HVR-950Q",
2632                 .ifnum = QUIRK_ANY_INTERFACE,
2633                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2634         }
2635 },
2636 {
2637         USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280),
2638         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2639                        USB_DEVICE_ID_MATCH_INT_CLASS |
2640                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2641         .bInterfaceClass = USB_CLASS_AUDIO,
2642         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2643         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2644                 .vendor_name = "Hauppauge",
2645                 .product_name = "HVR-950Q",
2646                 .ifnum = QUIRK_ANY_INTERFACE,
2647                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2648         }
2649 },
2650 {
2651         USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008),
2652         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2653                        USB_DEVICE_ID_MATCH_INT_CLASS |
2654                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2655         .bInterfaceClass = USB_CLASS_AUDIO,
2656         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2657         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2658                 .vendor_name = "Hauppauge",
2659                 .product_name = "HVR-950Q",
2660                 .ifnum = QUIRK_ANY_INTERFACE,
2661                 .type = QUIRK_AUDIO_ALIGN_TRANSFER,
2662         }
2663 },
2664
2665 /* Digidesign Mbox */
2666 {
2667         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2668         USB_DEVICE(0x0dba, 0x1000),
2669         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2670                 .vendor_name = "Digidesign",
2671                 .product_name = "MBox",
2672                 .ifnum = QUIRK_ANY_INTERFACE,
2673                 .type = QUIRK_COMPOSITE,
2674                 .data = (const struct snd_usb_audio_quirk[]){
2675                         {
2676                                 .ifnum = 0,
2677                                 .type = QUIRK_IGNORE_INTERFACE,
2678                         },
2679                         {
2680                                 .ifnum = 1,
2681                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2682                                 .data = &(const struct audioformat) {
2683                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2684                                         .channels = 2,
2685                                         .iface = 1,
2686                                         .altsetting = 1,
2687                                         .altset_idx = 1,
2688                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2689                                         .endpoint = 0x02,
2690                                         .ep_attr = 0x01,
2691                                         .maxpacksize = 0x130,
2692                                         .rates = SNDRV_PCM_RATE_44100 |
2693                                                  SNDRV_PCM_RATE_48000,
2694                                         .rate_min = 44100,
2695                                         .rate_max = 48000,
2696                                         .nr_rates = 2,
2697                                         .rate_table = (unsigned int[]) {
2698                                                 44100, 48000
2699                                         }
2700                                 }
2701                         },
2702                         {
2703                                 .ifnum = -1
2704                         }
2705                 }
2706
2707         }
2708 },
2709
2710 {
2711         /*
2712          * Some USB MIDI devices don't have an audio control interface,
2713          * so we have to grab MIDI streaming interfaces here.
2714          */
2715         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2716                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2717         .bInterfaceClass = USB_CLASS_AUDIO,
2718         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2719         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2720                 .ifnum = QUIRK_ANY_INTERFACE,
2721                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2722         }
2723 },
2724
2725 #undef USB_DEVICE_VENDOR_SPEC