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         USB_DEVICE(0x0582, 0x0159),
1808         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1809                 /* .vendor_name = "Roland", */
1810                 /* .product_name = "UA-22", */
1811                 .ifnum = QUIRK_ANY_INTERFACE,
1812                 .type = QUIRK_COMPOSITE,
1813                 .data = (const struct snd_usb_audio_quirk[]) {
1814                         {
1815                                 .ifnum = 0,
1816                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1817                         },
1818                         {
1819                                 .ifnum = 1,
1820                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1821                         },
1822                         {
1823                                 .ifnum = 2,
1824                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1825                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1826                                         .out_cables = 0x0001,
1827                                         .in_cables = 0x0001
1828                                 }
1829                         },
1830                         {
1831                                 .ifnum = -1
1832                         }
1833                 }
1834         }
1835 },
1836
1837 /* Guillemot devices */
1838 {
1839         /*
1840          * This is for the "Windows Edition" where the external MIDI ports are
1841          * the only MIDI ports; the control data is reported through HID
1842          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1843          * compliant USB MIDI ports for external MIDI and controls.
1844          */
1845         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1846         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1847                 .vendor_name = "Hercules",
1848                 .product_name = "DJ Console (WE)",
1849                 .ifnum = 4,
1850                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1851                 .data = & (const struct snd_usb_midi_endpoint_info) {
1852                         .out_cables = 0x0001,
1853                         .in_cables = 0x0001
1854                 }
1855         }
1856 },
1857
1858 /* Midiman/M-Audio devices */
1859 {
1860         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1861         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1862                 .vendor_name = "M-Audio",
1863                 .product_name = "MidiSport 2x2",
1864                 .ifnum = QUIRK_ANY_INTERFACE,
1865                 .type = QUIRK_MIDI_MIDIMAN,
1866                 .data = & (const struct snd_usb_midi_endpoint_info) {
1867                         .out_cables = 0x0003,
1868                         .in_cables  = 0x0003
1869                 }
1870         }
1871 },
1872 {
1873         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1874         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1875                 .vendor_name = "M-Audio",
1876                 .product_name = "MidiSport 1x1",
1877                 .ifnum = QUIRK_ANY_INTERFACE,
1878                 .type = QUIRK_MIDI_MIDIMAN,
1879                 .data = & (const struct snd_usb_midi_endpoint_info) {
1880                         .out_cables = 0x0001,
1881                         .in_cables  = 0x0001
1882                 }
1883         }
1884 },
1885 {
1886         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1887         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1888                 .vendor_name = "M-Audio",
1889                 .product_name = "Keystation",
1890                 .ifnum = QUIRK_ANY_INTERFACE,
1891                 .type = QUIRK_MIDI_MIDIMAN,
1892                 .data = & (const struct snd_usb_midi_endpoint_info) {
1893                         .out_cables = 0x0001,
1894                         .in_cables  = 0x0001
1895                 }
1896         }
1897 },
1898 {
1899         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1900         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1901                 .vendor_name = "M-Audio",
1902                 .product_name = "MidiSport 4x4",
1903                 .ifnum = QUIRK_ANY_INTERFACE,
1904                 .type = QUIRK_MIDI_MIDIMAN,
1905                 .data = & (const struct snd_usb_midi_endpoint_info) {
1906                         .out_cables = 0x000f,
1907                         .in_cables  = 0x000f
1908                 }
1909         }
1910 },
1911 {
1912         /*
1913          * For hardware revision 1.05; in the later revisions (1.10 and
1914          * 1.21), 0x1031 is the ID for the device without firmware.
1915          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1916          */
1917         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1918         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1919                 .vendor_name = "M-Audio",
1920                 .product_name = "MidiSport 8x8",
1921                 .ifnum = QUIRK_ANY_INTERFACE,
1922                 .type = QUIRK_MIDI_MIDIMAN,
1923                 .data = & (const struct snd_usb_midi_endpoint_info) {
1924                         .out_cables = 0x01ff,
1925                         .in_cables  = 0x01ff
1926                 }
1927         }
1928 },
1929 {
1930         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1931         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1932                 .vendor_name = "M-Audio",
1933                 .product_name = "MidiSport 8x8",
1934                 .ifnum = QUIRK_ANY_INTERFACE,
1935                 .type = QUIRK_MIDI_MIDIMAN,
1936                 .data = & (const struct snd_usb_midi_endpoint_info) {
1937                         .out_cables = 0x01ff,
1938                         .in_cables  = 0x01ff
1939                 }
1940         }
1941 },
1942 {
1943         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1944         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1945                 .vendor_name = "M-Audio",
1946                 .product_name = "MidiSport 2x4",
1947                 .ifnum = QUIRK_ANY_INTERFACE,
1948                 .type = QUIRK_MIDI_MIDIMAN,
1949                 .data = & (const struct snd_usb_midi_endpoint_info) {
1950                         .out_cables = 0x000f,
1951                         .in_cables  = 0x0003
1952                 }
1953         }
1954 },
1955 {
1956         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1957         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1958                 .vendor_name = "M-Audio",
1959                 .product_name = "Quattro",
1960                 .ifnum = QUIRK_ANY_INTERFACE,
1961                 .type = QUIRK_COMPOSITE,
1962                 .data = & (const struct snd_usb_audio_quirk[]) {
1963                         /*
1964                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1965                          * and share endpoints with the other interfaces.
1966                          * Ignore them.  The other interfaces can do 24 bits,
1967                          * but captured samples are big-endian (see usbaudio.c).
1968                          */
1969                         {
1970                                 .ifnum = 0,
1971                                 .type = QUIRK_IGNORE_INTERFACE
1972                         },
1973                         {
1974                                 .ifnum = 1,
1975                                 .type = QUIRK_IGNORE_INTERFACE
1976                         },
1977                         {
1978                                 .ifnum = 2,
1979                                 .type = QUIRK_IGNORE_INTERFACE
1980                         },
1981                         {
1982                                 .ifnum = 3,
1983                                 .type = QUIRK_IGNORE_INTERFACE
1984                         },
1985                         {
1986                                 .ifnum = 4,
1987                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1988                         },
1989                         {
1990                                 .ifnum = 5,
1991                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1992                         },
1993                         {
1994                                 .ifnum = 6,
1995                                 .type = QUIRK_IGNORE_INTERFACE
1996                         },
1997                         {
1998                                 .ifnum = 7,
1999                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2000                         },
2001                         {
2002                                 .ifnum = 8,
2003                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2004                         },
2005                         {
2006                                 .ifnum = 9,
2007                                 .type = QUIRK_MIDI_MIDIMAN,
2008                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2009                                         .out_cables = 0x0001,
2010                                         .in_cables  = 0x0001
2011                                 }
2012                         },
2013                         {
2014                                 .ifnum = -1
2015                         }
2016                 }
2017         }
2018 },
2019 {
2020         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
2021         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2022                 .vendor_name = "M-Audio",
2023                 .product_name = "AudioPhile",
2024                 .ifnum = 6,
2025                 .type = QUIRK_MIDI_MIDIMAN,
2026                 .data = & (const struct snd_usb_midi_endpoint_info) {
2027                         .out_cables = 0x0001,
2028                         .in_cables  = 0x0001
2029                 }
2030         }
2031 },
2032 {
2033         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
2034         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2035                 .vendor_name = "M-Audio",
2036                 .product_name = "Ozone",
2037                 .ifnum = 3,
2038                 .type = QUIRK_MIDI_MIDIMAN,
2039                 .data = & (const struct snd_usb_midi_endpoint_info) {
2040                         .out_cables = 0x0001,
2041                         .in_cables  = 0x0001
2042                 }
2043         }
2044 },
2045 {
2046         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
2047         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2048                 .vendor_name = "M-Audio",
2049                 .product_name = "OmniStudio",
2050                 .ifnum = QUIRK_ANY_INTERFACE,
2051                 .type = QUIRK_COMPOSITE,
2052                 .data = & (const struct snd_usb_audio_quirk[]) {
2053                         {
2054                                 .ifnum = 0,
2055                                 .type = QUIRK_IGNORE_INTERFACE
2056                         },
2057                         {
2058                                 .ifnum = 1,
2059                                 .type = QUIRK_IGNORE_INTERFACE
2060                         },
2061                         {
2062                                 .ifnum = 2,
2063                                 .type = QUIRK_IGNORE_INTERFACE
2064                         },
2065                         {
2066                                 .ifnum = 3,
2067                                 .type = QUIRK_IGNORE_INTERFACE
2068                         },
2069                         {
2070                                 .ifnum = 4,
2071                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2072                         },
2073                         {
2074                                 .ifnum = 5,
2075                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2076                         },
2077                         {
2078                                 .ifnum = 6,
2079                                 .type = QUIRK_IGNORE_INTERFACE
2080                         },
2081                         {
2082                                 .ifnum = 7,
2083                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2084                         },
2085                         {
2086                                 .ifnum = 8,
2087                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2088                         },
2089                         {
2090                                 .ifnum = 9,
2091                                 .type = QUIRK_MIDI_MIDIMAN,
2092                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2093                                         .out_cables = 0x0001,
2094                                         .in_cables  = 0x0001
2095                                 }
2096                         },
2097                         {
2098                                 .ifnum = -1
2099                         }
2100                 }
2101         }
2102 },
2103 {
2104         USB_DEVICE(0x0763, 0x2019),
2105         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2106                 /* .vendor_name = "M-Audio", */
2107                 /* .product_name = "Ozone Academic", */
2108                 .ifnum = QUIRK_ANY_INTERFACE,
2109                 .type = QUIRK_COMPOSITE,
2110                 .data = & (const struct snd_usb_audio_quirk[]) {
2111                         {
2112                                 .ifnum = 0,
2113                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2114                         },
2115                         {
2116                                 .ifnum = 1,
2117                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2118                         },
2119                         {
2120                                 .ifnum = 2,
2121                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2122                         },
2123                         {
2124                                 .ifnum = 3,
2125                                 .type = QUIRK_MIDI_MIDIMAN,
2126                                 .data = & (const struct snd_usb_midi_endpoint_info) {
2127                                         .out_cables = 0x0001,
2128                                         .in_cables  = 0x0001
2129                                 }
2130                         },
2131                         {
2132                                 .ifnum = -1
2133                         }
2134                 }
2135         }
2136 },
2137 {
2138         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
2139         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2140                 /* .vendor_name = "M-Audio", */
2141                 /* .product_name = "Fast Track Ultra", */
2142                 .ifnum = QUIRK_ANY_INTERFACE,
2143                 .type = QUIRK_COMPOSITE,
2144                 .data = & (const struct snd_usb_audio_quirk[]) {
2145                         {
2146                                 .ifnum = 0,
2147                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2148                         },
2149                         {
2150                                 .ifnum = 1,
2151                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2152                                 .data = & (const struct audioformat) {
2153                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2154                                         .channels = 8,
2155                                         .iface = 1,
2156                                         .altsetting = 1,
2157                                         .altset_idx = 1,
2158                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2159                                         .endpoint = 0x01,
2160                                         .ep_attr = 0x09,
2161                                         .rates = SNDRV_PCM_RATE_44100 |
2162                                                  SNDRV_PCM_RATE_48000 |
2163                                                  SNDRV_PCM_RATE_88200 |
2164                                                  SNDRV_PCM_RATE_96000,
2165                                         .rate_min = 44100,
2166                                         .rate_max = 96000,
2167                                         .nr_rates = 4,
2168                                         .rate_table = (unsigned int[]) {
2169                                                 44100, 48000, 88200, 96000
2170                                         }
2171                                 }
2172                         },
2173                         {
2174                                 .ifnum = 2,
2175                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2176                                 .data = & (const struct audioformat) {
2177                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2178                                         .channels = 8,
2179                                         .iface = 2,
2180                                         .altsetting = 1,
2181                                         .altset_idx = 1,
2182                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2183                                         .endpoint = 0x81,
2184                                         .ep_attr = 0x05,
2185                                         .rates = SNDRV_PCM_RATE_44100 |
2186                                                  SNDRV_PCM_RATE_48000 |
2187                                                  SNDRV_PCM_RATE_88200 |
2188                                                  SNDRV_PCM_RATE_96000,
2189                                         .rate_min = 44100,
2190                                         .rate_max = 96000,
2191                                         .nr_rates = 4,
2192                                         .rate_table = (unsigned int[]) {
2193                                                 44100, 48000, 88200, 96000
2194                                         }
2195                                 }
2196                         },
2197                         /* interface 3 (MIDI) is standard compliant */
2198                         {
2199                                 .ifnum = -1
2200                         }
2201                 }
2202         }
2203 },
2204 {
2205         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
2206         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2207                 /* .vendor_name = "M-Audio", */
2208                 /* .product_name = "Fast Track Ultra 8R", */
2209                 .ifnum = QUIRK_ANY_INTERFACE,
2210                 .type = QUIRK_COMPOSITE,
2211                 .data = & (const struct snd_usb_audio_quirk[]) {
2212                         {
2213                                 .ifnum = 0,
2214                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2215                         },
2216                         {
2217                                 .ifnum = 1,
2218                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2219                                 .data = & (const struct audioformat) {
2220                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2221                                         .channels = 8,
2222                                         .iface = 1,
2223                                         .altsetting = 1,
2224                                         .altset_idx = 1,
2225                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2226                                         .endpoint = 0x01,
2227                                         .ep_attr = 0x09,
2228                                         .rates = SNDRV_PCM_RATE_44100 |
2229                                                  SNDRV_PCM_RATE_48000 |
2230                                                  SNDRV_PCM_RATE_88200 |
2231                                                  SNDRV_PCM_RATE_96000,
2232                                         .rate_min = 44100,
2233                                         .rate_max = 96000,
2234                                         .nr_rates = 4,
2235                                         .rate_table = (unsigned int[]) {
2236                                                         44100, 48000, 88200, 96000
2237                                         }
2238                                 }
2239                         },
2240                         {
2241                                 .ifnum = 2,
2242                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2243                                 .data = & (const struct audioformat) {
2244                                         .formats = SNDRV_PCM_FMTBIT_S24_3LE,
2245                                         .channels = 8,
2246                                         .iface = 2,
2247                                         .altsetting = 1,
2248                                         .altset_idx = 1,
2249                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2250                                         .endpoint = 0x81,
2251                                         .ep_attr = 0x05,
2252                                         .rates = SNDRV_PCM_RATE_44100 |
2253                                                  SNDRV_PCM_RATE_48000 |
2254                                                  SNDRV_PCM_RATE_88200 |
2255                                                  SNDRV_PCM_RATE_96000,
2256                                         .rate_min = 44100,
2257                                         .rate_max = 96000,
2258                                         .nr_rates = 4,
2259                                         .rate_table = (unsigned int[]) {
2260                                                 44100, 48000, 88200, 96000
2261                                         }
2262                                 }
2263                         },
2264                         /* interface 3 (MIDI) is standard compliant */
2265                         {
2266                                 .ifnum = -1
2267                         }
2268                 }
2269         }
2270 },
2271
2272 /* Casio devices */
2273 {
2274         USB_DEVICE(0x07cf, 0x6801),
2275         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2276                 .vendor_name = "Casio",
2277                 .product_name = "PL-40R",
2278                 .ifnum = 0,
2279                 .type = QUIRK_MIDI_YAMAHA
2280         }
2281 },
2282 {
2283         /* this ID is used by several devices without a product ID */
2284         USB_DEVICE(0x07cf, 0x6802),
2285         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2286                 .vendor_name = "Casio",
2287                 .product_name = "Keyboard",
2288                 .ifnum = 0,
2289                 .type = QUIRK_MIDI_YAMAHA
2290         }
2291 },
2292
2293 /* Mark of the Unicorn devices */
2294 {
2295         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
2296         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
2297                        USB_DEVICE_ID_MATCH_PRODUCT |
2298                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
2299         .idVendor = 0x07fd,
2300         .idProduct = 0x0001,
2301         .bDeviceSubClass = 2,
2302         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2303                 .vendor_name = "MOTU",
2304                 .product_name = "Fastlane",
2305                 .ifnum = QUIRK_ANY_INTERFACE,
2306                 .type = QUIRK_COMPOSITE,
2307                 .data = & (const struct snd_usb_audio_quirk[]) {
2308                         {
2309                                 .ifnum = 0,
2310                                 .type = QUIRK_MIDI_RAW_BYTES
2311                         },
2312                         {
2313                                 .ifnum = 1,
2314                                 .type = QUIRK_IGNORE_INTERFACE
2315                         },
2316                         {
2317                                 .ifnum = -1
2318                         }
2319                 }
2320         }
2321 },
2322
2323 /* Emagic devices */
2324 {
2325         USB_DEVICE(0x086a, 0x0001),
2326         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2327                 .vendor_name = "Emagic",
2328                 /* .product_name = "Unitor8", */
2329                 .ifnum = 2,
2330                 .type = QUIRK_MIDI_EMAGIC,
2331                 .data = & (const struct snd_usb_midi_endpoint_info) {
2332                         .out_cables = 0x80ff,
2333                         .in_cables  = 0x80ff
2334                 }
2335         }
2336 },
2337 {
2338         USB_DEVICE(0x086a, 0x0002),
2339         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2340                 .vendor_name = "Emagic",
2341                 /* .product_name = "AMT8", */
2342                 .ifnum = 2,
2343                 .type = QUIRK_MIDI_EMAGIC,
2344                 .data = & (const struct snd_usb_midi_endpoint_info) {
2345                         .out_cables = 0x80ff,
2346                         .in_cables  = 0x80ff
2347                 }
2348         }
2349 },
2350 {
2351         USB_DEVICE(0x086a, 0x0003),
2352         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2353                 .vendor_name = "Emagic",
2354                 /* .product_name = "MT4", */
2355                 .ifnum = 2,
2356                 .type = QUIRK_MIDI_EMAGIC,
2357                 .data = & (const struct snd_usb_midi_endpoint_info) {
2358                         .out_cables = 0x800f,
2359                         .in_cables  = 0x8003
2360                 }
2361         }
2362 },
2363
2364 /* KORG devices */
2365 {
2366         USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
2367         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2368                 .vendor_name = "KORG, Inc.",
2369                 /* .product_name = "PANDORA PX5D", */
2370                 .ifnum = 3,
2371                 .type = QUIRK_MIDI_STANDARD_INTERFACE,
2372         }
2373 },
2374
2375 /* AKAI devices */
2376 {
2377         USB_DEVICE(0x09e8, 0x0062),
2378         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2379                 .vendor_name = "AKAI",
2380                 .product_name = "MPD16",
2381                 .ifnum = 0,
2382                 .type = QUIRK_MIDI_AKAI,
2383         }
2384 },
2385
2386 /* Steinberg devices */
2387 {
2388         /* Steinberg MI2 */
2389         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
2390         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2391                 .ifnum = QUIRK_ANY_INTERFACE,
2392                 .type = QUIRK_COMPOSITE,
2393                 .data = & (const struct snd_usb_audio_quirk[]) {
2394                         {
2395                                 .ifnum = 0,
2396                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2397                         },
2398                         {
2399                                 .ifnum = 1,
2400                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2401                         },
2402                         {
2403                                 .ifnum = 2,
2404                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2405                         },
2406                         {
2407                                 .ifnum = 3,
2408                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2409                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2410                                         .out_cables = 0x0001,
2411                                         .in_cables  = 0x0001
2412                                 }
2413                         },
2414                         {
2415                                 .ifnum = -1
2416                         }
2417                 }
2418         }
2419 },
2420 {
2421         /* Steinberg MI4 */
2422         USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
2423         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2424                 .ifnum = QUIRK_ANY_INTERFACE,
2425                 .type = QUIRK_COMPOSITE,
2426                 .data = & (const struct snd_usb_audio_quirk[]) {
2427                         {
2428                                 .ifnum = 0,
2429                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2430                         },
2431                         {
2432                                 .ifnum = 1,
2433                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2434                         },
2435                         {
2436                                 .ifnum = 2,
2437                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
2438                         },
2439                         {
2440                                 .ifnum = 3,
2441                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2442                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2443                                         .out_cables = 0x0001,
2444                                         .in_cables  = 0x0001
2445                                 }
2446                         },
2447                         {
2448                                 .ifnum = -1
2449                         }
2450                 }
2451         }
2452 },
2453
2454 /* TerraTec devices */
2455 {
2456         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
2457         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2458                 .vendor_name = "TerraTec",
2459                 .product_name = "PHASE 26",
2460                 .ifnum = 3,
2461                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2462         }
2463 },
2464 {
2465         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
2466         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2467                 .vendor_name = "TerraTec",
2468                 .product_name = "PHASE 26",
2469                 .ifnum = 3,
2470                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2471         }
2472 },
2473 {
2474         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
2475         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2476                 .vendor_name = "TerraTec",
2477                 .product_name = "PHASE 26",
2478                 .ifnum = 3,
2479                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2480         }
2481 },
2482 {
2483         USB_DEVICE(0x0ccd, 0x0028),
2484         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2485                 .vendor_name = "TerraTec",
2486                 .product_name = "Aureon5.1MkII",
2487                 .ifnum = QUIRK_NO_INTERFACE
2488         }
2489 },
2490 {
2491         USB_DEVICE(0x0ccd, 0x0035),
2492         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2493                 .vendor_name = "Miditech",
2494                 .product_name = "Play'n Roll",
2495                 .ifnum = 0,
2496                 .type = QUIRK_MIDI_CME
2497         }
2498 },
2499
2500 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
2501 {
2502         USB_DEVICE(0x103d, 0x0100),
2503                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2504                 .vendor_name = "Stanton",
2505                 .product_name = "ScratchAmp",
2506                 .ifnum = QUIRK_NO_INTERFACE
2507         }
2508 },
2509 {
2510         USB_DEVICE(0x103d, 0x0101),
2511                 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2512                 .vendor_name = "Stanton",
2513                 .product_name = "ScratchAmp",
2514                 .ifnum = QUIRK_NO_INTERFACE
2515         }
2516 },
2517
2518 /* Novation EMS devices */
2519 {
2520         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
2521         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2522                 .vendor_name = "Novation",
2523                 .product_name = "ReMOTE Audio/XStation",
2524                 .ifnum = 4,
2525                 .type = QUIRK_MIDI_NOVATION
2526         }
2527 },
2528 {
2529         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
2530         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2531                 .vendor_name = "Novation",
2532                 .product_name = "Speedio",
2533                 .ifnum = 3,
2534                 .type = QUIRK_MIDI_NOVATION
2535         }
2536 },
2537 {
2538         USB_DEVICE(0x1235, 0x000e),
2539         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2540                 /* .vendor_name = "Novation", */
2541                 /* .product_name = "Launchpad", */
2542                 .ifnum = 0,
2543                 .type = QUIRK_MIDI_RAW_BYTES
2544         }
2545 },
2546 {
2547         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
2548         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2549                 .vendor_name = "Novation",
2550                 .product_name = "ReMOTE25",
2551                 .ifnum = 0,
2552                 .type = QUIRK_MIDI_NOVATION
2553         }
2554 },
2555
2556 /* Access Music devices */
2557 {
2558         /* VirusTI Desktop */
2559         USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
2560         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2561                 .ifnum = QUIRK_ANY_INTERFACE,
2562                 .type = QUIRK_COMPOSITE,
2563                 .data = &(const struct snd_usb_audio_quirk[]) {
2564                         {
2565                                 .ifnum = 3,
2566                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
2567                                 .data = &(const struct snd_usb_midi_endpoint_info) {
2568                                         .out_cables = 0x0003,
2569                                         .in_cables  = 0x0003
2570                                 }
2571                         },
2572                         {
2573                                 .ifnum = 4,
2574                                 .type = QUIRK_IGNORE_INTERFACE
2575                         },
2576                         {
2577                                 .ifnum = -1
2578                         }
2579                 }
2580         }
2581 },
2582
2583 /* */
2584 {
2585         /* aka. Serato Scratch Live DJ Box */
2586         USB_DEVICE(0x13e5, 0x0001),
2587         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2588                 .vendor_name = "Rane",
2589                 .product_name = "SL-1",
2590                 .ifnum = QUIRK_NO_INTERFACE
2591         }
2592 },
2593
2594 /* Native Instruments MK2 series */
2595 {
2596         /* Komplete Audio 6 */
2597         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2598         .idVendor = 0x17cc,
2599         .idProduct = 0x1000,
2600 },
2601 {
2602         /* Traktor Audio 6 */
2603         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2604         .idVendor = 0x17cc,
2605         .idProduct = 0x1010,
2606 },
2607 {
2608         /* Traktor Audio 10 */
2609         .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
2610         .idVendor = 0x17cc,
2611         .idProduct = 0x1020,
2612 },
2613
2614 /* QinHeng devices */
2615 {
2616         USB_DEVICE(0x1a86, 0x752d),
2617         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2618                 .vendor_name = "QinHeng",
2619                 .product_name = "CH345",
2620                 .ifnum = 1,
2621                 .type = QUIRK_MIDI_CH345
2622         }
2623 },
2624
2625 /* KeithMcMillen Stringport */
2626 {
2627         USB_DEVICE(0x1f38, 0x0001),
2628         .bInterfaceClass = USB_CLASS_AUDIO,
2629 },
2630
2631 /* Miditech devices */
2632 {
2633         USB_DEVICE(0x4752, 0x0011),
2634         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2635                 .vendor_name = "Miditech",
2636                 .product_name = "Midistart-2",
2637                 .ifnum = 0,
2638                 .type = QUIRK_MIDI_CME
2639         }
2640 },
2641
2642 /* Central Music devices */
2643 {
2644         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
2645         USB_DEVICE(0x7104, 0x2202),
2646         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2647                 .ifnum = 0,
2648                 .type = QUIRK_MIDI_CME
2649         }
2650 },
2651
2652 /*
2653  * Auvitek au0828 devices with audio interface.
2654  * This should be kept in sync with drivers/media/video/au0828/au0828-cards.c
2655  * Please notice that some drivers are DVB only, and don't need to be
2656  * here. That's the case, for example, of DVICO_FUSIONHDTV7.
2657  */
2658
2659 #define AU0828_DEVICE(vid, pid, vname, pname) { \
2660         USB_DEVICE_VENDOR_SPEC(vid, pid), \
2661         .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
2662                        USB_DEVICE_ID_MATCH_INT_CLASS | \
2663                        USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
2664         .bInterfaceClass = USB_CLASS_AUDIO, \
2665         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
2666         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
2667                 .vendor_name = vname, \
2668                 .product_name = pname, \
2669                 .ifnum = QUIRK_ANY_INTERFACE, \
2670                 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
2671         } \
2672 }
2673
2674 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
2675 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
2676 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
2677 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
2678 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
2679 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
2680 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
2681 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
2682 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
2683 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
2684 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
2685 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
2686 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
2687 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
2688 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
2689 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
2690 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
2691
2692 /* Syntek STK1160 */
2693 {
2694         .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
2695                        USB_DEVICE_ID_MATCH_INT_CLASS |
2696                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2697         .idVendor = 0x05e1,
2698         .idProduct = 0x0408,
2699         .bInterfaceClass = USB_CLASS_AUDIO,
2700         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
2701         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2702                 .vendor_name = "Syntek",
2703                 .product_name = "STK1160",
2704                 .ifnum = QUIRK_ANY_INTERFACE,
2705                 .type = QUIRK_AUDIO_ALIGN_TRANSFER
2706         }
2707 },
2708
2709 /* Digidesign Mbox */
2710 {
2711         /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
2712         USB_DEVICE(0x0dba, 0x1000),
2713         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2714                 .vendor_name = "Digidesign",
2715                 .product_name = "MBox",
2716                 .ifnum = QUIRK_ANY_INTERFACE,
2717                 .type = QUIRK_COMPOSITE,
2718                 .data = (const struct snd_usb_audio_quirk[]){
2719                         {
2720                                 .ifnum = 0,
2721                                 .type = QUIRK_IGNORE_INTERFACE,
2722                         },
2723                         {
2724                                 .ifnum = 1,
2725                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2726                                 .data = &(const struct audioformat) {
2727                                         .formats = SNDRV_PCM_FMTBIT_S24_3BE,
2728                                         .channels = 2,
2729                                         .iface = 1,
2730                                         .altsetting = 1,
2731                                         .altset_idx = 1,
2732                                         .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
2733                                         .endpoint = 0x02,
2734                                         .ep_attr = 0x01,
2735                                         .maxpacksize = 0x130,
2736                                         .rates = SNDRV_PCM_RATE_44100 |
2737                                                  SNDRV_PCM_RATE_48000,
2738                                         .rate_min = 44100,
2739                                         .rate_max = 48000,
2740                                         .nr_rates = 2,
2741                                         .rate_table = (unsigned int[]) {
2742                                                 44100, 48000
2743                                         }
2744                                 }
2745                         },
2746                         {
2747                                 .ifnum = -1
2748                         }
2749                 }
2750
2751         }
2752 },
2753
2754 {
2755         /*
2756          * Some USB MIDI devices don't have an audio control interface,
2757          * so we have to grab MIDI streaming interfaces here.
2758          */
2759         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
2760                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
2761         .bInterfaceClass = USB_CLASS_AUDIO,
2762         .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
2763         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
2764                 .ifnum = QUIRK_ANY_INTERFACE,
2765                 .type = QUIRK_MIDI_STANDARD_INTERFACE
2766         }
2767 },
2768
2769 {
2770         /*
2771          * Bower's & Wilkins PX headphones only support the 48 kHz sample rate
2772          * even though it advertises more. The capture interface doesn't work
2773          * even on windows.
2774          */
2775         USB_DEVICE(0x19b5, 0x0021),
2776         .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
2777                 .ifnum = QUIRK_ANY_INTERFACE,
2778                 .type = QUIRK_COMPOSITE,
2779                 .data = (const struct snd_usb_audio_quirk[]) {
2780                         {
2781                                 .ifnum = 0,
2782                                 .type = QUIRK_AUDIO_STANDARD_MIXER,
2783                         },
2784                         /* Capture */
2785                         {
2786                                 .ifnum = 1,
2787                                 .type = QUIRK_IGNORE_INTERFACE,
2788                         },
2789                         /* Playback */
2790                         {
2791                                 .ifnum = 2,
2792                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
2793                                 .data = &(const struct audioformat) {
2794                                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
2795                                         .channels = 2,
2796                                         .iface = 2,
2797                                         .altsetting = 1,
2798                                         .altset_idx = 1,
2799                                         .attributes = UAC_EP_CS_ATTR_FILL_MAX |
2800                                                 UAC_EP_CS_ATTR_SAMPLE_RATE,
2801                                         .endpoint = 0x03,
2802                                         .ep_attr = USB_ENDPOINT_XFER_ISOC,
2803                                         .rates = SNDRV_PCM_RATE_48000,
2804                                         .rate_min = 48000,
2805                                         .rate_max = 48000,
2806                                         .nr_rates = 1,
2807                                         .rate_table = (unsigned int[]) {
2808                                                 48000
2809                                         }
2810                                 }
2811                         },
2812                 }
2813         }
2814 },
2815
2816 #undef USB_DEVICE_VENDOR_SPEC