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