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