1 /* SPDX-License-Identifier: GPL-2.0-or-later */ 2 /* 3 * ALSA USB Audio Driver 4 * 5 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>, 6 * Clemens Ladisch <clemens@ladisch.de> 7 */ 8 9 /* 10 * The contents of this file are part of the driver's id_table. 11 * 12 * In a perfect world, this file would be empty. 13 */ 14 15 /* 16 * Use this for devices where other interfaces are standard compliant, 17 * to prevent the quirk being applied to those interfaces. (To work with 18 * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.) 19 */ 20 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \ 21 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \ 22 USB_DEVICE_ID_MATCH_PRODUCT | \ 23 USB_DEVICE_ID_MATCH_INT_CLASS, \ 24 .idVendor = vend, \ 25 .idProduct = prod, \ 26 .bInterfaceClass = USB_CLASS_VENDOR_SPEC 27 28 #define QUIRK_RENAME_DEVICE(_vendor, _device) \ 29 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ 30 .vendor_name = _vendor, \ 31 .product_name = _device, \ 32 .ifnum = QUIRK_NO_INTERFACE \ 33 } 34 35 #define QUIRK_DEVICE_PROFILE(_vendor, _device, _profile) \ 36 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ 37 .vendor_name = _vendor, \ 38 .product_name = _device, \ 39 .profile_name = _profile, \ 40 .ifnum = QUIRK_NO_INTERFACE \ 41 } 42 43 /* HP Thunderbolt Dock Audio Headset */ 44 { 45 USB_DEVICE(0x03f0, 0x0269), 46 QUIRK_DEVICE_PROFILE("HP", "Thunderbolt Dock Audio Headset", 47 "HP-Thunderbolt-Dock-Audio-Headset"), 48 }, 49 /* HP Thunderbolt Dock Audio Module */ 50 { 51 USB_DEVICE(0x03f0, 0x0567), 52 QUIRK_DEVICE_PROFILE("HP", "Thunderbolt Dock Audio Module", 53 "HP-Thunderbolt-Dock-Audio-Module"), 54 }, 55 /* FTDI devices */ 56 { 57 USB_DEVICE(0x0403, 0xb8d8), 58 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 59 /* .vendor_name = "STARR LABS", */ 60 /* .product_name = "Starr Labs MIDI USB device", */ 61 .ifnum = 0, 62 .type = QUIRK_MIDI_FTDI 63 } 64 }, 65 66 { 67 /* Creative BT-D1 */ 68 USB_DEVICE(0x041e, 0x0005), 69 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 70 .ifnum = 1, 71 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 72 .data = &(const struct audioformat) { 73 .formats = SNDRV_PCM_FMTBIT_S16_LE, 74 .channels = 2, 75 .iface = 1, 76 .altsetting = 1, 77 .altset_idx = 1, 78 .endpoint = 0x03, 79 .ep_attr = USB_ENDPOINT_XFER_ISOC, 80 .attributes = 0, 81 .rates = SNDRV_PCM_RATE_CONTINUOUS, 82 .rate_min = 48000, 83 .rate_max = 48000, 84 } 85 } 86 }, 87 88 /* Creative/E-Mu devices */ 89 { 90 USB_DEVICE(0x041e, 0x3010), 91 QUIRK_RENAME_DEVICE("Creative Labs", "Sound Blaster MP3+") 92 }, 93 /* Creative/Toshiba Multimedia Center SB-0500 */ 94 { 95 USB_DEVICE(0x041e, 0x3048), 96 QUIRK_RENAME_DEVICE("Toshiba", "SB-0500") 97 }, 98 { 99 /* E-Mu 0202 USB */ 100 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 101 .idVendor = 0x041e, 102 .idProduct = 0x3f02, 103 .bInterfaceClass = USB_CLASS_AUDIO, 104 }, 105 { 106 /* E-Mu 0404 USB */ 107 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 108 .idVendor = 0x041e, 109 .idProduct = 0x3f04, 110 .bInterfaceClass = USB_CLASS_AUDIO, 111 }, 112 { 113 /* E-Mu Tracker Pre */ 114 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 115 .idVendor = 0x041e, 116 .idProduct = 0x3f0a, 117 .bInterfaceClass = USB_CLASS_AUDIO, 118 }, 119 { 120 /* E-Mu 0204 USB */ 121 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 122 .idVendor = 0x041e, 123 .idProduct = 0x3f19, 124 .bInterfaceClass = USB_CLASS_AUDIO, 125 }, 126 127 /* 128 * HP Wireless Audio 129 * When not ignored, causes instability issues for some users, forcing them to 130 * skip the entire module. 131 */ 132 { 133 USB_DEVICE(0x0424, 0xb832), 134 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 135 .vendor_name = "Standard Microsystems Corp.", 136 .product_name = "HP Wireless Audio", 137 .ifnum = QUIRK_ANY_INTERFACE, 138 .type = QUIRK_COMPOSITE, 139 .data = (const struct snd_usb_audio_quirk[]) { 140 /* Mixer */ 141 { 142 .ifnum = 0, 143 .type = QUIRK_IGNORE_INTERFACE, 144 }, 145 /* Playback */ 146 { 147 .ifnum = 1, 148 .type = QUIRK_IGNORE_INTERFACE, 149 }, 150 /* Capture */ 151 { 152 .ifnum = 2, 153 .type = QUIRK_IGNORE_INTERFACE, 154 }, 155 /* HID Device, .ifnum = 3 */ 156 { 157 .ifnum = -1, 158 } 159 } 160 } 161 }, 162 163 /* 164 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface 165 * class matches do not take effect without an explicit ID match. 166 */ 167 { 168 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 169 USB_DEVICE_ID_MATCH_INT_CLASS | 170 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 171 .idVendor = 0x046d, 172 .idProduct = 0x0850, 173 .bInterfaceClass = USB_CLASS_AUDIO, 174 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 175 }, 176 { 177 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 178 USB_DEVICE_ID_MATCH_INT_CLASS | 179 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 180 .idVendor = 0x046d, 181 .idProduct = 0x08ae, 182 .bInterfaceClass = USB_CLASS_AUDIO, 183 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 184 }, 185 { 186 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 187 USB_DEVICE_ID_MATCH_INT_CLASS | 188 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 189 .idVendor = 0x046d, 190 .idProduct = 0x08c6, 191 .bInterfaceClass = USB_CLASS_AUDIO, 192 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 193 }, 194 { 195 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 196 USB_DEVICE_ID_MATCH_INT_CLASS | 197 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 198 .idVendor = 0x046d, 199 .idProduct = 0x08f0, 200 .bInterfaceClass = USB_CLASS_AUDIO, 201 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 202 }, 203 { 204 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 205 USB_DEVICE_ID_MATCH_INT_CLASS | 206 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 207 .idVendor = 0x046d, 208 .idProduct = 0x08f5, 209 .bInterfaceClass = USB_CLASS_AUDIO, 210 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 211 }, 212 { 213 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 214 USB_DEVICE_ID_MATCH_INT_CLASS | 215 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 216 .idVendor = 0x046d, 217 .idProduct = 0x08f6, 218 .bInterfaceClass = USB_CLASS_AUDIO, 219 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 220 }, 221 { 222 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 223 USB_DEVICE_ID_MATCH_INT_CLASS | 224 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 225 .idVendor = 0x046d, 226 .idProduct = 0x0990, 227 .bInterfaceClass = USB_CLASS_AUDIO, 228 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 229 QUIRK_RENAME_DEVICE("Logitech, Inc.", "QuickCam Pro 9000") 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, 0x1509), 390 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 391 /* .vendor_name = "Yamaha", */ 392 /* .product_name = "Steinberg UR22", */ 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 = 4, 410 .type = QUIRK_IGNORE_INTERFACE 411 }, 412 { 413 .ifnum = -1 414 } 415 } 416 } 417 }, 418 { 419 USB_DEVICE(0x0499, 0x150a), 420 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 421 /* .vendor_name = "Yamaha", */ 422 /* .product_name = "THR5A", */ 423 .ifnum = QUIRK_ANY_INTERFACE, 424 .type = QUIRK_COMPOSITE, 425 .data = (const struct snd_usb_audio_quirk[]) { 426 { 427 .ifnum = 1, 428 .type = QUIRK_AUDIO_STANDARD_INTERFACE 429 }, 430 { 431 .ifnum = 2, 432 .type = QUIRK_AUDIO_STANDARD_INTERFACE 433 }, 434 { 435 .ifnum = 3, 436 .type = QUIRK_MIDI_YAMAHA 437 }, 438 { 439 .ifnum = -1 440 } 441 } 442 } 443 }, 444 { 445 USB_DEVICE(0x0499, 0x150c), 446 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 447 /* .vendor_name = "Yamaha", */ 448 /* .product_name = "THR10C", */ 449 .ifnum = QUIRK_ANY_INTERFACE, 450 .type = QUIRK_COMPOSITE, 451 .data = (const struct snd_usb_audio_quirk[]) { 452 { 453 .ifnum = 1, 454 .type = QUIRK_AUDIO_STANDARD_INTERFACE 455 }, 456 { 457 .ifnum = 2, 458 .type = QUIRK_AUDIO_STANDARD_INTERFACE 459 }, 460 { 461 .ifnum = 3, 462 .type = QUIRK_MIDI_YAMAHA 463 }, 464 { 465 .ifnum = -1 466 } 467 } 468 } 469 }, 470 YAMAHA_DEVICE(0x2000, "DGP-7"), 471 YAMAHA_DEVICE(0x2001, "DGP-5"), 472 YAMAHA_DEVICE(0x2002, NULL), 473 YAMAHA_DEVICE(0x2003, NULL), 474 YAMAHA_DEVICE(0x5000, "CS1D"), 475 YAMAHA_DEVICE(0x5001, "DSP1D"), 476 YAMAHA_DEVICE(0x5002, "DME32"), 477 YAMAHA_DEVICE(0x5003, "DM2000"), 478 YAMAHA_DEVICE(0x5004, "02R96"), 479 YAMAHA_DEVICE(0x5005, "ACU16-C"), 480 YAMAHA_DEVICE(0x5006, "NHB32-C"), 481 YAMAHA_DEVICE(0x5007, "DM1000"), 482 YAMAHA_DEVICE(0x5008, "01V96"), 483 YAMAHA_DEVICE(0x5009, "SPX2000"), 484 YAMAHA_DEVICE(0x500a, "PM5D"), 485 YAMAHA_DEVICE(0x500b, "DME64N"), 486 YAMAHA_DEVICE(0x500c, "DME24N"), 487 YAMAHA_DEVICE(0x500d, NULL), 488 YAMAHA_DEVICE(0x500e, NULL), 489 YAMAHA_DEVICE(0x500f, NULL), 490 YAMAHA_DEVICE(0x7000, "DTX"), 491 YAMAHA_DEVICE(0x7010, "UB99"), 492 #undef YAMAHA_DEVICE 493 #undef YAMAHA_INTERFACE 494 /* this catches most recent vendor-specific Yamaha devices */ 495 { 496 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 497 USB_DEVICE_ID_MATCH_INT_CLASS, 498 .idVendor = 0x0499, 499 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 500 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 501 .ifnum = QUIRK_ANY_INTERFACE, 502 .type = QUIRK_AUTODETECT 503 } 504 }, 505 506 /* 507 * Roland/RolandED/Edirol/BOSS devices 508 */ 509 { 510 USB_DEVICE(0x0582, 0x0000), 511 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 512 .vendor_name = "Roland", 513 .product_name = "UA-100", 514 .ifnum = QUIRK_ANY_INTERFACE, 515 .type = QUIRK_COMPOSITE, 516 .data = (const struct snd_usb_audio_quirk[]) { 517 { 518 .ifnum = 0, 519 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 520 .data = & (const struct audioformat) { 521 .formats = SNDRV_PCM_FMTBIT_S16_LE, 522 .channels = 4, 523 .iface = 0, 524 .altsetting = 1, 525 .altset_idx = 1, 526 .attributes = 0, 527 .endpoint = 0x01, 528 .ep_attr = 0x09, 529 .rates = SNDRV_PCM_RATE_CONTINUOUS, 530 .rate_min = 44100, 531 .rate_max = 44100, 532 } 533 }, 534 { 535 .ifnum = 1, 536 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 537 .data = & (const struct audioformat) { 538 .formats = SNDRV_PCM_FMTBIT_S16_LE, 539 .channels = 2, 540 .iface = 1, 541 .altsetting = 1, 542 .altset_idx = 1, 543 .attributes = UAC_EP_CS_ATTR_FILL_MAX, 544 .endpoint = 0x81, 545 .ep_attr = 0x05, 546 .rates = SNDRV_PCM_RATE_CONTINUOUS, 547 .rate_min = 44100, 548 .rate_max = 44100, 549 } 550 }, 551 { 552 .ifnum = 2, 553 .type = QUIRK_MIDI_FIXED_ENDPOINT, 554 .data = & (const struct snd_usb_midi_endpoint_info) { 555 .out_cables = 0x0007, 556 .in_cables = 0x0007 557 } 558 }, 559 { 560 .ifnum = -1 561 } 562 } 563 } 564 }, 565 { 566 USB_DEVICE(0x0582, 0x0002), 567 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 568 .vendor_name = "EDIROL", 569 .product_name = "UM-4", 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 = 0x000f, 586 .in_cables = 0x000f 587 } 588 }, 589 { 590 .ifnum = -1 591 } 592 } 593 } 594 }, 595 { 596 USB_DEVICE(0x0582, 0x0003), 597 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 598 .vendor_name = "Roland", 599 .product_name = "SC-8850", 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 = 0x003f, 616 .in_cables = 0x003f 617 } 618 }, 619 { 620 .ifnum = -1 621 } 622 } 623 } 624 }, 625 { 626 USB_DEVICE(0x0582, 0x0004), 627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 628 .vendor_name = "Roland", 629 .product_name = "U-8", 630 .ifnum = QUIRK_ANY_INTERFACE, 631 .type = QUIRK_COMPOSITE, 632 .data = (const struct snd_usb_audio_quirk[]) { 633 { 634 .ifnum = 0, 635 .type = QUIRK_IGNORE_INTERFACE 636 }, 637 { 638 .ifnum = 1, 639 .type = QUIRK_IGNORE_INTERFACE 640 }, 641 { 642 .ifnum = 2, 643 .type = QUIRK_MIDI_FIXED_ENDPOINT, 644 .data = & (const struct snd_usb_midi_endpoint_info) { 645 .out_cables = 0x0005, 646 .in_cables = 0x0005 647 } 648 }, 649 { 650 .ifnum = -1 651 } 652 } 653 } 654 }, 655 { 656 /* Has ID 0x0099 when not in "Advanced Driver" mode. 657 * The UM-2EX has only one input, but we cannot detect this. */ 658 USB_DEVICE(0x0582, 0x0005), 659 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 660 .vendor_name = "EDIROL", 661 .product_name = "UM-2", 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 = 0x0003, 678 .in_cables = 0x0003 679 } 680 }, 681 { 682 .ifnum = -1 683 } 684 } 685 } 686 }, 687 { 688 USB_DEVICE(0x0582, 0x0007), 689 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 690 .vendor_name = "Roland", 691 .product_name = "SC-8820", 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 = 0x0013, 708 .in_cables = 0x0013 709 } 710 }, 711 { 712 .ifnum = -1 713 } 714 } 715 } 716 }, 717 { 718 USB_DEVICE(0x0582, 0x0008), 719 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 720 .vendor_name = "Roland", 721 .product_name = "PC-300", 722 .ifnum = QUIRK_ANY_INTERFACE, 723 .type = QUIRK_COMPOSITE, 724 .data = (const struct snd_usb_audio_quirk[]) { 725 { 726 .ifnum = 0, 727 .type = QUIRK_IGNORE_INTERFACE 728 }, 729 { 730 .ifnum = 1, 731 .type = QUIRK_IGNORE_INTERFACE 732 }, 733 { 734 .ifnum = 2, 735 .type = QUIRK_MIDI_FIXED_ENDPOINT, 736 .data = & (const struct snd_usb_midi_endpoint_info) { 737 .out_cables = 0x0001, 738 .in_cables = 0x0001 739 } 740 }, 741 { 742 .ifnum = -1 743 } 744 } 745 } 746 }, 747 { 748 /* has ID 0x009d when not in "Advanced Driver" mode */ 749 USB_DEVICE(0x0582, 0x0009), 750 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 751 .vendor_name = "EDIROL", 752 .product_name = "UM-1", 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 = 0x0001, 769 .in_cables = 0x0001 770 } 771 }, 772 { 773 .ifnum = -1 774 } 775 } 776 } 777 }, 778 { 779 USB_DEVICE(0x0582, 0x000b), 780 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 781 .vendor_name = "Roland", 782 .product_name = "SK-500", 783 .ifnum = QUIRK_ANY_INTERFACE, 784 .type = QUIRK_COMPOSITE, 785 .data = (const struct snd_usb_audio_quirk[]) { 786 { 787 .ifnum = 0, 788 .type = QUIRK_IGNORE_INTERFACE 789 }, 790 { 791 .ifnum = 1, 792 .type = QUIRK_IGNORE_INTERFACE 793 }, 794 { 795 .ifnum = 2, 796 .type = QUIRK_MIDI_FIXED_ENDPOINT, 797 .data = & (const struct snd_usb_midi_endpoint_info) { 798 .out_cables = 0x0013, 799 .in_cables = 0x0013 800 } 801 }, 802 { 803 .ifnum = -1 804 } 805 } 806 } 807 }, 808 { 809 /* thanks to Emiliano Grilli <emillo@libero.it> 810 * for helping researching this data */ 811 USB_DEVICE(0x0582, 0x000c), 812 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 813 .vendor_name = "Roland", 814 .product_name = "SC-D70", 815 .ifnum = QUIRK_ANY_INTERFACE, 816 .type = QUIRK_COMPOSITE, 817 .data = (const struct snd_usb_audio_quirk[]) { 818 { 819 .ifnum = 0, 820 .type = QUIRK_AUDIO_STANDARD_INTERFACE 821 }, 822 { 823 .ifnum = 1, 824 .type = QUIRK_AUDIO_STANDARD_INTERFACE 825 }, 826 { 827 .ifnum = 2, 828 .type = QUIRK_MIDI_FIXED_ENDPOINT, 829 .data = & (const struct snd_usb_midi_endpoint_info) { 830 .out_cables = 0x0007, 831 .in_cables = 0x0007 832 } 833 }, 834 { 835 .ifnum = -1 836 } 837 } 838 } 839 }, 840 { /* 841 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5. 842 * If the advanced mode switch at the back of the unit is off, the 843 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks), 844 * but offers only 16-bit PCM. 845 * In advanced mode, the UA-5 will output S24_3LE samples (two 846 * channels) at the rate indicated on the front switch, including 847 * the 96kHz sample rate. 848 */ 849 USB_DEVICE(0x0582, 0x0010), 850 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 851 .vendor_name = "EDIROL", 852 .product_name = "UA-5", 853 .ifnum = QUIRK_ANY_INTERFACE, 854 .type = QUIRK_COMPOSITE, 855 .data = (const struct snd_usb_audio_quirk[]) { 856 { 857 .ifnum = 1, 858 .type = QUIRK_AUDIO_STANDARD_INTERFACE 859 }, 860 { 861 .ifnum = 2, 862 .type = QUIRK_AUDIO_STANDARD_INTERFACE 863 }, 864 { 865 .ifnum = -1 866 } 867 } 868 } 869 }, 870 { 871 /* has ID 0x0013 when not in "Advanced Driver" mode */ 872 USB_DEVICE(0x0582, 0x0012), 873 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 874 .vendor_name = "Roland", 875 .product_name = "XV-5050", 876 .ifnum = 0, 877 .type = QUIRK_MIDI_FIXED_ENDPOINT, 878 .data = & (const struct snd_usb_midi_endpoint_info) { 879 .out_cables = 0x0001, 880 .in_cables = 0x0001 881 } 882 } 883 }, 884 { 885 /* has ID 0x0015 when not in "Advanced Driver" mode */ 886 USB_DEVICE(0x0582, 0x0014), 887 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 888 .vendor_name = "EDIROL", 889 .product_name = "UM-880", 890 .ifnum = 0, 891 .type = QUIRK_MIDI_FIXED_ENDPOINT, 892 .data = & (const struct snd_usb_midi_endpoint_info) { 893 .out_cables = 0x01ff, 894 .in_cables = 0x01ff 895 } 896 } 897 }, 898 { 899 /* has ID 0x0017 when not in "Advanced Driver" mode */ 900 USB_DEVICE(0x0582, 0x0016), 901 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 902 .vendor_name = "EDIROL", 903 .product_name = "SD-90", 904 .ifnum = QUIRK_ANY_INTERFACE, 905 .type = QUIRK_COMPOSITE, 906 .data = (const struct snd_usb_audio_quirk[]) { 907 { 908 .ifnum = 0, 909 .type = QUIRK_AUDIO_STANDARD_INTERFACE 910 }, 911 { 912 .ifnum = 1, 913 .type = QUIRK_AUDIO_STANDARD_INTERFACE 914 }, 915 { 916 .ifnum = 2, 917 .type = QUIRK_MIDI_FIXED_ENDPOINT, 918 .data = & (const struct snd_usb_midi_endpoint_info) { 919 .out_cables = 0x000f, 920 .in_cables = 0x000f 921 } 922 }, 923 { 924 .ifnum = -1 925 } 926 } 927 } 928 }, 929 { 930 /* has ID 0x001c when not in "Advanced Driver" mode */ 931 USB_DEVICE(0x0582, 0x001b), 932 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 933 .vendor_name = "Roland", 934 .product_name = "MMP-2", 935 .ifnum = QUIRK_ANY_INTERFACE, 936 .type = QUIRK_COMPOSITE, 937 .data = (const struct snd_usb_audio_quirk[]) { 938 { 939 .ifnum = 0, 940 .type = QUIRK_IGNORE_INTERFACE 941 }, 942 { 943 .ifnum = 1, 944 .type = QUIRK_IGNORE_INTERFACE 945 }, 946 { 947 .ifnum = 2, 948 .type = QUIRK_MIDI_FIXED_ENDPOINT, 949 .data = & (const struct snd_usb_midi_endpoint_info) { 950 .out_cables = 0x0001, 951 .in_cables = 0x0001 952 } 953 }, 954 { 955 .ifnum = -1 956 } 957 } 958 } 959 }, 960 { 961 /* has ID 0x001e when not in "Advanced Driver" mode */ 962 USB_DEVICE(0x0582, 0x001d), 963 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 964 .vendor_name = "Roland", 965 .product_name = "V-SYNTH", 966 .ifnum = 0, 967 .type = QUIRK_MIDI_FIXED_ENDPOINT, 968 .data = & (const struct snd_usb_midi_endpoint_info) { 969 .out_cables = 0x0001, 970 .in_cables = 0x0001 971 } 972 } 973 }, 974 { 975 /* has ID 0x0024 when not in "Advanced Driver" mode */ 976 USB_DEVICE(0x0582, 0x0023), 977 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 978 .vendor_name = "EDIROL", 979 .product_name = "UM-550", 980 .ifnum = 0, 981 .type = QUIRK_MIDI_FIXED_ENDPOINT, 982 .data = & (const struct snd_usb_midi_endpoint_info) { 983 .out_cables = 0x003f, 984 .in_cables = 0x003f 985 } 986 } 987 }, 988 { 989 /* 990 * This quirk is for the "Advanced Driver" mode. If off, the UA-20 991 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM 992 * and no MIDI. 993 */ 994 USB_DEVICE(0x0582, 0x0025), 995 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 996 .vendor_name = "EDIROL", 997 .product_name = "UA-20", 998 .ifnum = QUIRK_ANY_INTERFACE, 999 .type = QUIRK_COMPOSITE, 1000 .data = (const struct snd_usb_audio_quirk[]) { 1001 { 1002 .ifnum = 0, 1003 .type = QUIRK_IGNORE_INTERFACE 1004 }, 1005 { 1006 .ifnum = 1, 1007 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1008 .data = & (const struct audioformat) { 1009 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 1010 .channels = 2, 1011 .iface = 1, 1012 .altsetting = 1, 1013 .altset_idx = 1, 1014 .attributes = 0, 1015 .endpoint = 0x01, 1016 .ep_attr = 0x01, 1017 .rates = SNDRV_PCM_RATE_CONTINUOUS, 1018 .rate_min = 44100, 1019 .rate_max = 44100, 1020 } 1021 }, 1022 { 1023 .ifnum = 2, 1024 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1025 .data = & (const struct audioformat) { 1026 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 1027 .channels = 2, 1028 .iface = 2, 1029 .altsetting = 1, 1030 .altset_idx = 1, 1031 .attributes = 0, 1032 .endpoint = 0x82, 1033 .ep_attr = 0x01, 1034 .rates = SNDRV_PCM_RATE_CONTINUOUS, 1035 .rate_min = 44100, 1036 .rate_max = 44100, 1037 } 1038 }, 1039 { 1040 .ifnum = 3, 1041 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1042 .data = & (const struct snd_usb_midi_endpoint_info) { 1043 .out_cables = 0x0001, 1044 .in_cables = 0x0001 1045 } 1046 }, 1047 { 1048 .ifnum = -1 1049 } 1050 } 1051 } 1052 }, 1053 { 1054 /* has ID 0x0028 when not in "Advanced Driver" mode */ 1055 USB_DEVICE(0x0582, 0x0027), 1056 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1057 .vendor_name = "EDIROL", 1058 .product_name = "SD-20", 1059 .ifnum = 0, 1060 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1061 .data = & (const struct snd_usb_midi_endpoint_info) { 1062 .out_cables = 0x0003, 1063 .in_cables = 0x0007 1064 } 1065 } 1066 }, 1067 { 1068 /* has ID 0x002a when not in "Advanced Driver" mode */ 1069 USB_DEVICE(0x0582, 0x0029), 1070 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1071 .vendor_name = "EDIROL", 1072 .product_name = "SD-80", 1073 .ifnum = 0, 1074 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1075 .data = & (const struct snd_usb_midi_endpoint_info) { 1076 .out_cables = 0x000f, 1077 .in_cables = 0x000f 1078 } 1079 } 1080 }, 1081 { /* 1082 * This quirk is for the "Advanced" modes of the Edirol UA-700. 1083 * If the sample format switch is not in an advanced setting, the 1084 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks), 1085 * but offers only 16-bit PCM and no MIDI. 1086 */ 1087 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b), 1088 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1089 .vendor_name = "EDIROL", 1090 .product_name = "UA-700", 1091 .ifnum = QUIRK_ANY_INTERFACE, 1092 .type = QUIRK_COMPOSITE, 1093 .data = (const struct snd_usb_audio_quirk[]) { 1094 { 1095 .ifnum = 1, 1096 .type = QUIRK_AUDIO_EDIROL_UAXX 1097 }, 1098 { 1099 .ifnum = 2, 1100 .type = QUIRK_AUDIO_EDIROL_UAXX 1101 }, 1102 { 1103 .ifnum = 3, 1104 .type = QUIRK_AUDIO_EDIROL_UAXX 1105 }, 1106 { 1107 .ifnum = -1 1108 } 1109 } 1110 } 1111 }, 1112 { 1113 /* has ID 0x002e when not in "Advanced Driver" mode */ 1114 USB_DEVICE(0x0582, 0x002d), 1115 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1116 .vendor_name = "Roland", 1117 .product_name = "XV-2020", 1118 .ifnum = 0, 1119 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1120 .data = & (const struct snd_usb_midi_endpoint_info) { 1121 .out_cables = 0x0001, 1122 .in_cables = 0x0001 1123 } 1124 } 1125 }, 1126 { 1127 /* has ID 0x0030 when not in "Advanced Driver" mode */ 1128 USB_DEVICE(0x0582, 0x002f), 1129 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1130 .vendor_name = "Roland", 1131 .product_name = "VariOS", 1132 .ifnum = 0, 1133 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1134 .data = & (const struct snd_usb_midi_endpoint_info) { 1135 .out_cables = 0x0007, 1136 .in_cables = 0x0007 1137 } 1138 } 1139 }, 1140 { 1141 /* has ID 0x0034 when not in "Advanced Driver" mode */ 1142 USB_DEVICE(0x0582, 0x0033), 1143 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1144 .vendor_name = "EDIROL", 1145 .product_name = "PCR", 1146 .ifnum = 0, 1147 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1148 .data = & (const struct snd_usb_midi_endpoint_info) { 1149 .out_cables = 0x0003, 1150 .in_cables = 0x0007 1151 } 1152 } 1153 }, 1154 { 1155 /* 1156 * Has ID 0x0038 when not in "Advanced Driver" mode; 1157 * later revisions use IDs 0x0054 and 0x00a2. 1158 */ 1159 USB_DEVICE(0x0582, 0x0037), 1160 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1161 .vendor_name = "Roland", 1162 .product_name = "Digital Piano", 1163 .ifnum = 0, 1164 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1165 .data = & (const struct snd_usb_midi_endpoint_info) { 1166 .out_cables = 0x0001, 1167 .in_cables = 0x0001 1168 } 1169 } 1170 }, 1171 { 1172 /* 1173 * This quirk is for the "Advanced Driver" mode. If off, the GS-10 1174 * has ID 0x003c and is standard compliant, but has only 16-bit PCM 1175 * and no MIDI. 1176 */ 1177 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b), 1178 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1179 .vendor_name = "BOSS", 1180 .product_name = "GS-10", 1181 .ifnum = QUIRK_ANY_INTERFACE, 1182 .type = QUIRK_COMPOSITE, 1183 .data = & (const struct snd_usb_audio_quirk[]) { 1184 { 1185 .ifnum = 1, 1186 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1187 }, 1188 { 1189 .ifnum = 2, 1190 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1191 }, 1192 { 1193 .ifnum = 3, 1194 .type = QUIRK_MIDI_STANDARD_INTERFACE 1195 }, 1196 { 1197 .ifnum = -1 1198 } 1199 } 1200 } 1201 }, 1202 { 1203 /* has ID 0x0041 when not in "Advanced Driver" mode */ 1204 USB_DEVICE(0x0582, 0x0040), 1205 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1206 .vendor_name = "Roland", 1207 .product_name = "GI-20", 1208 .ifnum = 0, 1209 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1210 .data = & (const struct snd_usb_midi_endpoint_info) { 1211 .out_cables = 0x0001, 1212 .in_cables = 0x0001 1213 } 1214 } 1215 }, 1216 { 1217 /* has ID 0x0043 when not in "Advanced Driver" mode */ 1218 USB_DEVICE(0x0582, 0x0042), 1219 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1220 .vendor_name = "Roland", 1221 .product_name = "RS-70", 1222 .ifnum = 0, 1223 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1224 .data = & (const struct snd_usb_midi_endpoint_info) { 1225 .out_cables = 0x0001, 1226 .in_cables = 0x0001 1227 } 1228 } 1229 }, 1230 { 1231 /* has ID 0x0049 when not in "Advanced Driver" mode */ 1232 USB_DEVICE(0x0582, 0x0047), 1233 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1234 /* .vendor_name = "EDIROL", */ 1235 /* .product_name = "UR-80", */ 1236 .ifnum = QUIRK_ANY_INTERFACE, 1237 .type = QUIRK_COMPOSITE, 1238 .data = (const struct snd_usb_audio_quirk[]) { 1239 /* in the 96 kHz modes, only interface 1 is there */ 1240 { 1241 .ifnum = 1, 1242 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1243 }, 1244 { 1245 .ifnum = 2, 1246 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1247 }, 1248 { 1249 .ifnum = -1 1250 } 1251 } 1252 } 1253 }, 1254 { 1255 /* has ID 0x004a when not in "Advanced Driver" mode */ 1256 USB_DEVICE(0x0582, 0x0048), 1257 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1258 /* .vendor_name = "EDIROL", */ 1259 /* .product_name = "UR-80", */ 1260 .ifnum = 0, 1261 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1262 .data = & (const struct snd_usb_midi_endpoint_info) { 1263 .out_cables = 0x0003, 1264 .in_cables = 0x0007 1265 } 1266 } 1267 }, 1268 { 1269 /* has ID 0x004e when not in "Advanced Driver" mode */ 1270 USB_DEVICE(0x0582, 0x004c), 1271 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1272 .vendor_name = "EDIROL", 1273 .product_name = "PCR-A", 1274 .ifnum = QUIRK_ANY_INTERFACE, 1275 .type = QUIRK_COMPOSITE, 1276 .data = (const struct snd_usb_audio_quirk[]) { 1277 { 1278 .ifnum = 1, 1279 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1280 }, 1281 { 1282 .ifnum = 2, 1283 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1284 }, 1285 { 1286 .ifnum = -1 1287 } 1288 } 1289 } 1290 }, 1291 { 1292 /* has ID 0x004f when not in "Advanced Driver" mode */ 1293 USB_DEVICE(0x0582, 0x004d), 1294 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1295 .vendor_name = "EDIROL", 1296 .product_name = "PCR-A", 1297 .ifnum = 0, 1298 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1299 .data = & (const struct snd_usb_midi_endpoint_info) { 1300 .out_cables = 0x0003, 1301 .in_cables = 0x0007 1302 } 1303 } 1304 }, 1305 { 1306 /* 1307 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX 1308 * is standard compliant, but has only 16-bit PCM. 1309 */ 1310 USB_DEVICE(0x0582, 0x0050), 1311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1312 .vendor_name = "EDIROL", 1313 .product_name = "UA-3FX", 1314 .ifnum = QUIRK_ANY_INTERFACE, 1315 .type = QUIRK_COMPOSITE, 1316 .data = (const struct snd_usb_audio_quirk[]) { 1317 { 1318 .ifnum = 1, 1319 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1320 }, 1321 { 1322 .ifnum = 2, 1323 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1324 }, 1325 { 1326 .ifnum = -1 1327 } 1328 } 1329 } 1330 }, 1331 { 1332 USB_DEVICE(0x0582, 0x0052), 1333 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1334 .vendor_name = "EDIROL", 1335 .product_name = "UM-1SX", 1336 .ifnum = 0, 1337 .type = QUIRK_MIDI_STANDARD_INTERFACE 1338 } 1339 }, 1340 { 1341 USB_DEVICE(0x0582, 0x0060), 1342 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1343 .vendor_name = "Roland", 1344 .product_name = "EXR Series", 1345 .ifnum = 0, 1346 .type = QUIRK_MIDI_STANDARD_INTERFACE 1347 } 1348 }, 1349 { 1350 /* has ID 0x0066 when not in "Advanced Driver" mode */ 1351 USB_DEVICE(0x0582, 0x0064), 1352 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1353 /* .vendor_name = "EDIROL", */ 1354 /* .product_name = "PCR-1", */ 1355 .ifnum = QUIRK_ANY_INTERFACE, 1356 .type = QUIRK_COMPOSITE, 1357 .data = (const struct snd_usb_audio_quirk[]) { 1358 { 1359 .ifnum = 1, 1360 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1361 }, 1362 { 1363 .ifnum = 2, 1364 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1365 }, 1366 { 1367 .ifnum = -1 1368 } 1369 } 1370 } 1371 }, 1372 { 1373 /* has ID 0x0067 when not in "Advanced Driver" mode */ 1374 USB_DEVICE(0x0582, 0x0065), 1375 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1376 /* .vendor_name = "EDIROL", */ 1377 /* .product_name = "PCR-1", */ 1378 .ifnum = 0, 1379 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1380 .data = & (const struct snd_usb_midi_endpoint_info) { 1381 .out_cables = 0x0001, 1382 .in_cables = 0x0003 1383 } 1384 } 1385 }, 1386 { 1387 /* has ID 0x006e when not in "Advanced Driver" mode */ 1388 USB_DEVICE(0x0582, 0x006d), 1389 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1390 .vendor_name = "Roland", 1391 .product_name = "FANTOM-X", 1392 .ifnum = 0, 1393 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1394 .data = & (const struct snd_usb_midi_endpoint_info) { 1395 .out_cables = 0x0001, 1396 .in_cables = 0x0001 1397 } 1398 } 1399 }, 1400 { /* 1401 * This quirk is for the "Advanced" modes of the Edirol UA-25. 1402 * If the switch is not in an advanced setting, the UA-25 has 1403 * ID 0x0582/0x0073 and is standard compliant (no quirks), but 1404 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1405 */ 1406 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074), 1407 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1408 .vendor_name = "EDIROL", 1409 .product_name = "UA-25", 1410 .ifnum = QUIRK_ANY_INTERFACE, 1411 .type = QUIRK_COMPOSITE, 1412 .data = (const struct snd_usb_audio_quirk[]) { 1413 { 1414 .ifnum = 0, 1415 .type = QUIRK_AUDIO_EDIROL_UAXX 1416 }, 1417 { 1418 .ifnum = 1, 1419 .type = QUIRK_AUDIO_EDIROL_UAXX 1420 }, 1421 { 1422 .ifnum = 2, 1423 .type = QUIRK_AUDIO_EDIROL_UAXX 1424 }, 1425 { 1426 .ifnum = -1 1427 } 1428 } 1429 } 1430 }, 1431 { 1432 /* has ID 0x0076 when not in "Advanced Driver" mode */ 1433 USB_DEVICE(0x0582, 0x0075), 1434 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1435 .vendor_name = "BOSS", 1436 .product_name = "DR-880", 1437 .ifnum = 0, 1438 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1439 .data = & (const struct snd_usb_midi_endpoint_info) { 1440 .out_cables = 0x0001, 1441 .in_cables = 0x0001 1442 } 1443 } 1444 }, 1445 { 1446 /* has ID 0x007b when not in "Advanced Driver" mode */ 1447 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a), 1448 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1449 .vendor_name = "Roland", 1450 /* "RD" or "RD-700SX"? */ 1451 .ifnum = 0, 1452 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1453 .data = & (const struct snd_usb_midi_endpoint_info) { 1454 .out_cables = 0x0003, 1455 .in_cables = 0x0003 1456 } 1457 } 1458 }, 1459 { 1460 /* has ID 0x0081 when not in "Advanced Driver" mode */ 1461 USB_DEVICE(0x0582, 0x0080), 1462 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1463 .vendor_name = "Roland", 1464 .product_name = "G-70", 1465 .ifnum = 0, 1466 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1467 .data = & (const struct snd_usb_midi_endpoint_info) { 1468 .out_cables = 0x0001, 1469 .in_cables = 0x0001 1470 } 1471 } 1472 }, 1473 { 1474 /* has ID 0x008c when not in "Advanced Driver" mode */ 1475 USB_DEVICE(0x0582, 0x008b), 1476 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1477 .vendor_name = "EDIROL", 1478 .product_name = "PC-50", 1479 .ifnum = 0, 1480 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1481 .data = & (const struct snd_usb_midi_endpoint_info) { 1482 .out_cables = 0x0001, 1483 .in_cables = 0x0001 1484 } 1485 } 1486 }, 1487 { 1488 /* 1489 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX 1490 * is standard compliant, but has only 16-bit PCM and no MIDI. 1491 */ 1492 USB_DEVICE(0x0582, 0x00a3), 1493 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1494 .vendor_name = "EDIROL", 1495 .product_name = "UA-4FX", 1496 .ifnum = QUIRK_ANY_INTERFACE, 1497 .type = QUIRK_COMPOSITE, 1498 .data = (const struct snd_usb_audio_quirk[]) { 1499 { 1500 .ifnum = 0, 1501 .type = QUIRK_AUDIO_EDIROL_UAXX 1502 }, 1503 { 1504 .ifnum = 1, 1505 .type = QUIRK_AUDIO_EDIROL_UAXX 1506 }, 1507 { 1508 .ifnum = 2, 1509 .type = QUIRK_AUDIO_EDIROL_UAXX 1510 }, 1511 { 1512 .ifnum = -1 1513 } 1514 } 1515 } 1516 }, 1517 { 1518 /* Edirol M-16DX */ 1519 USB_DEVICE(0x0582, 0x00c4), 1520 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1521 .ifnum = QUIRK_ANY_INTERFACE, 1522 .type = QUIRK_COMPOSITE, 1523 .data = (const struct snd_usb_audio_quirk[]) { 1524 { 1525 .ifnum = 0, 1526 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1527 }, 1528 { 1529 .ifnum = 1, 1530 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1531 }, 1532 { 1533 .ifnum = 2, 1534 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1535 .data = & (const struct snd_usb_midi_endpoint_info) { 1536 .out_cables = 0x0001, 1537 .in_cables = 0x0001 1538 } 1539 }, 1540 { 1541 .ifnum = -1 1542 } 1543 } 1544 } 1545 }, 1546 { 1547 /* Advanced modes of the Edirol UA-25EX. 1548 * For the standard mode, UA-25EX has ID 0582:00e7, which 1549 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1550 */ 1551 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6), 1552 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1553 .vendor_name = "EDIROL", 1554 .product_name = "UA-25EX", 1555 .ifnum = QUIRK_ANY_INTERFACE, 1556 .type = QUIRK_COMPOSITE, 1557 .data = (const struct snd_usb_audio_quirk[]) { 1558 { 1559 .ifnum = 0, 1560 .type = QUIRK_AUDIO_EDIROL_UAXX 1561 }, 1562 { 1563 .ifnum = 1, 1564 .type = QUIRK_AUDIO_EDIROL_UAXX 1565 }, 1566 { 1567 .ifnum = 2, 1568 .type = QUIRK_AUDIO_EDIROL_UAXX 1569 }, 1570 { 1571 .ifnum = -1 1572 } 1573 } 1574 } 1575 }, 1576 { 1577 /* Edirol UM-3G */ 1578 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108), 1579 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1580 .ifnum = 0, 1581 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1582 .data = & (const struct snd_usb_midi_endpoint_info) { 1583 .out_cables = 0x0007, 1584 .in_cables = 0x0007 1585 } 1586 } 1587 }, 1588 { 1589 /* BOSS ME-25 */ 1590 USB_DEVICE(0x0582, 0x0113), 1591 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1592 .ifnum = QUIRK_ANY_INTERFACE, 1593 .type = QUIRK_COMPOSITE, 1594 .data = (const struct snd_usb_audio_quirk[]) { 1595 { 1596 .ifnum = 0, 1597 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1598 }, 1599 { 1600 .ifnum = 1, 1601 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1602 }, 1603 { 1604 .ifnum = 2, 1605 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1606 .data = & (const struct snd_usb_midi_endpoint_info) { 1607 .out_cables = 0x0001, 1608 .in_cables = 0x0001 1609 } 1610 }, 1611 { 1612 .ifnum = -1 1613 } 1614 } 1615 } 1616 }, 1617 { 1618 /* only 44.1 kHz works at the moment */ 1619 USB_DEVICE(0x0582, 0x0120), 1620 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1621 /* .vendor_name = "Roland", */ 1622 /* .product_name = "OCTO-CAPTURE", */ 1623 .ifnum = QUIRK_ANY_INTERFACE, 1624 .type = QUIRK_COMPOSITE, 1625 .data = (const struct snd_usb_audio_quirk[]) { 1626 { 1627 .ifnum = 0, 1628 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1629 .data = & (const struct audioformat) { 1630 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1631 .channels = 10, 1632 .iface = 0, 1633 .altsetting = 1, 1634 .altset_idx = 1, 1635 .endpoint = 0x05, 1636 .ep_attr = 0x05, 1637 .rates = SNDRV_PCM_RATE_44100, 1638 .rate_min = 44100, 1639 .rate_max = 44100, 1640 .nr_rates = 1, 1641 .rate_table = (unsigned int[]) { 44100 } 1642 } 1643 }, 1644 { 1645 .ifnum = 1, 1646 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1647 .data = & (const struct audioformat) { 1648 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1649 .channels = 12, 1650 .iface = 1, 1651 .altsetting = 1, 1652 .altset_idx = 1, 1653 .endpoint = 0x85, 1654 .ep_attr = 0x25, 1655 .rates = SNDRV_PCM_RATE_44100, 1656 .rate_min = 44100, 1657 .rate_max = 44100, 1658 .nr_rates = 1, 1659 .rate_table = (unsigned int[]) { 44100 } 1660 } 1661 }, 1662 { 1663 .ifnum = 2, 1664 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1665 .data = & (const struct snd_usb_midi_endpoint_info) { 1666 .out_cables = 0x0001, 1667 .in_cables = 0x0001 1668 } 1669 }, 1670 { 1671 .ifnum = 3, 1672 .type = QUIRK_IGNORE_INTERFACE 1673 }, 1674 { 1675 .ifnum = 4, 1676 .type = QUIRK_IGNORE_INTERFACE 1677 }, 1678 { 1679 .ifnum = -1 1680 } 1681 } 1682 } 1683 }, 1684 { 1685 /* only 44.1 kHz works at the moment */ 1686 USB_DEVICE(0x0582, 0x012f), 1687 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1688 /* .vendor_name = "Roland", */ 1689 /* .product_name = "QUAD-CAPTURE", */ 1690 .ifnum = QUIRK_ANY_INTERFACE, 1691 .type = QUIRK_COMPOSITE, 1692 .data = (const struct snd_usb_audio_quirk[]) { 1693 { 1694 .ifnum = 0, 1695 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1696 .data = & (const struct audioformat) { 1697 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1698 .channels = 4, 1699 .iface = 0, 1700 .altsetting = 1, 1701 .altset_idx = 1, 1702 .endpoint = 0x05, 1703 .ep_attr = 0x05, 1704 .rates = SNDRV_PCM_RATE_44100, 1705 .rate_min = 44100, 1706 .rate_max = 44100, 1707 .nr_rates = 1, 1708 .rate_table = (unsigned int[]) { 44100 } 1709 } 1710 }, 1711 { 1712 .ifnum = 1, 1713 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1714 .data = & (const struct audioformat) { 1715 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1716 .channels = 6, 1717 .iface = 1, 1718 .altsetting = 1, 1719 .altset_idx = 1, 1720 .endpoint = 0x85, 1721 .ep_attr = 0x25, 1722 .rates = SNDRV_PCM_RATE_44100, 1723 .rate_min = 44100, 1724 .rate_max = 44100, 1725 .nr_rates = 1, 1726 .rate_table = (unsigned int[]) { 44100 } 1727 } 1728 }, 1729 { 1730 .ifnum = 2, 1731 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1732 .data = & (const struct snd_usb_midi_endpoint_info) { 1733 .out_cables = 0x0001, 1734 .in_cables = 0x0001 1735 } 1736 }, 1737 { 1738 .ifnum = 3, 1739 .type = QUIRK_IGNORE_INTERFACE 1740 }, 1741 { 1742 .ifnum = 4, 1743 .type = QUIRK_IGNORE_INTERFACE 1744 }, 1745 { 1746 .ifnum = -1 1747 } 1748 } 1749 } 1750 }, 1751 { 1752 USB_DEVICE(0x0582, 0x0159), 1753 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1754 /* .vendor_name = "Roland", */ 1755 /* .product_name = "UA-22", */ 1756 .ifnum = QUIRK_ANY_INTERFACE, 1757 .type = QUIRK_COMPOSITE, 1758 .data = (const struct snd_usb_audio_quirk[]) { 1759 { 1760 .ifnum = 0, 1761 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1762 }, 1763 { 1764 .ifnum = 1, 1765 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1766 }, 1767 { 1768 .ifnum = 2, 1769 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1770 .data = & (const struct snd_usb_midi_endpoint_info) { 1771 .out_cables = 0x0001, 1772 .in_cables = 0x0001 1773 } 1774 }, 1775 { 1776 .ifnum = -1 1777 } 1778 } 1779 } 1780 }, 1781 /* this catches most recent vendor-specific Roland devices */ 1782 { 1783 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 1784 USB_DEVICE_ID_MATCH_INT_CLASS, 1785 .idVendor = 0x0582, 1786 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 1787 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 1788 .ifnum = QUIRK_ANY_INTERFACE, 1789 .type = QUIRK_AUTODETECT 1790 } 1791 }, 1792 1793 /* Guillemot devices */ 1794 { 1795 /* 1796 * This is for the "Windows Edition" where the external MIDI ports are 1797 * the only MIDI ports; the control data is reported through HID 1798 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1799 * compliant USB MIDI ports for external MIDI and controls. 1800 */ 1801 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1802 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1803 .vendor_name = "Hercules", 1804 .product_name = "DJ Console (WE)", 1805 .ifnum = 4, 1806 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1807 .data = & (const struct snd_usb_midi_endpoint_info) { 1808 .out_cables = 0x0001, 1809 .in_cables = 0x0001 1810 } 1811 } 1812 }, 1813 1814 /* Midiman/M-Audio devices */ 1815 { 1816 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1817 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1818 .vendor_name = "M-Audio", 1819 .product_name = "MidiSport 2x2", 1820 .ifnum = QUIRK_ANY_INTERFACE, 1821 .type = QUIRK_MIDI_MIDIMAN, 1822 .data = & (const struct snd_usb_midi_endpoint_info) { 1823 .out_cables = 0x0003, 1824 .in_cables = 0x0003 1825 } 1826 } 1827 }, 1828 { 1829 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1830 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1831 .vendor_name = "M-Audio", 1832 .product_name = "MidiSport 1x1", 1833 .ifnum = QUIRK_ANY_INTERFACE, 1834 .type = QUIRK_MIDI_MIDIMAN, 1835 .data = & (const struct snd_usb_midi_endpoint_info) { 1836 .out_cables = 0x0001, 1837 .in_cables = 0x0001 1838 } 1839 } 1840 }, 1841 { 1842 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1843 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1844 .vendor_name = "M-Audio", 1845 .product_name = "Keystation", 1846 .ifnum = QUIRK_ANY_INTERFACE, 1847 .type = QUIRK_MIDI_MIDIMAN, 1848 .data = & (const struct snd_usb_midi_endpoint_info) { 1849 .out_cables = 0x0001, 1850 .in_cables = 0x0001 1851 } 1852 } 1853 }, 1854 { 1855 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1856 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1857 .vendor_name = "M-Audio", 1858 .product_name = "MidiSport 4x4", 1859 .ifnum = QUIRK_ANY_INTERFACE, 1860 .type = QUIRK_MIDI_MIDIMAN, 1861 .data = & (const struct snd_usb_midi_endpoint_info) { 1862 .out_cables = 0x000f, 1863 .in_cables = 0x000f 1864 } 1865 } 1866 }, 1867 { 1868 /* 1869 * For hardware revision 1.05; in the later revisions (1.10 and 1870 * 1.21), 0x1031 is the ID for the device without firmware. 1871 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1872 */ 1873 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1874 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1875 .vendor_name = "M-Audio", 1876 .product_name = "MidiSport 8x8", 1877 .ifnum = QUIRK_ANY_INTERFACE, 1878 .type = QUIRK_MIDI_MIDIMAN, 1879 .data = & (const struct snd_usb_midi_endpoint_info) { 1880 .out_cables = 0x01ff, 1881 .in_cables = 0x01ff 1882 } 1883 } 1884 }, 1885 { 1886 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1887 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1888 .vendor_name = "M-Audio", 1889 .product_name = "MidiSport 8x8", 1890 .ifnum = QUIRK_ANY_INTERFACE, 1891 .type = QUIRK_MIDI_MIDIMAN, 1892 .data = & (const struct snd_usb_midi_endpoint_info) { 1893 .out_cables = 0x01ff, 1894 .in_cables = 0x01ff 1895 } 1896 } 1897 }, 1898 { 1899 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1900 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1901 .vendor_name = "M-Audio", 1902 .product_name = "MidiSport 2x4", 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 = 0x0003 1908 } 1909 } 1910 }, 1911 { 1912 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1913 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1914 .vendor_name = "M-Audio", 1915 .product_name = "Quattro", 1916 .ifnum = QUIRK_ANY_INTERFACE, 1917 .type = QUIRK_COMPOSITE, 1918 .data = & (const struct snd_usb_audio_quirk[]) { 1919 /* 1920 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1921 * and share endpoints with the other interfaces. 1922 * Ignore them. The other interfaces can do 24 bits, 1923 * but captured samples are big-endian (see usbaudio.c). 1924 */ 1925 { 1926 .ifnum = 0, 1927 .type = QUIRK_IGNORE_INTERFACE 1928 }, 1929 { 1930 .ifnum = 1, 1931 .type = QUIRK_IGNORE_INTERFACE 1932 }, 1933 { 1934 .ifnum = 2, 1935 .type = QUIRK_IGNORE_INTERFACE 1936 }, 1937 { 1938 .ifnum = 3, 1939 .type = QUIRK_IGNORE_INTERFACE 1940 }, 1941 { 1942 .ifnum = 4, 1943 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1944 }, 1945 { 1946 .ifnum = 5, 1947 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1948 }, 1949 { 1950 .ifnum = 6, 1951 .type = QUIRK_IGNORE_INTERFACE 1952 }, 1953 { 1954 .ifnum = 7, 1955 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1956 }, 1957 { 1958 .ifnum = 8, 1959 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1960 }, 1961 { 1962 .ifnum = 9, 1963 .type = QUIRK_MIDI_MIDIMAN, 1964 .data = & (const struct snd_usb_midi_endpoint_info) { 1965 .out_cables = 0x0001, 1966 .in_cables = 0x0001 1967 } 1968 }, 1969 { 1970 .ifnum = -1 1971 } 1972 } 1973 } 1974 }, 1975 { 1976 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 1977 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1978 .vendor_name = "M-Audio", 1979 .product_name = "AudioPhile", 1980 .ifnum = 6, 1981 .type = QUIRK_MIDI_MIDIMAN, 1982 .data = & (const struct snd_usb_midi_endpoint_info) { 1983 .out_cables = 0x0001, 1984 .in_cables = 0x0001 1985 } 1986 } 1987 }, 1988 { 1989 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 1990 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1991 .vendor_name = "M-Audio", 1992 .product_name = "Ozone", 1993 .ifnum = 3, 1994 .type = QUIRK_MIDI_MIDIMAN, 1995 .data = & (const struct snd_usb_midi_endpoint_info) { 1996 .out_cables = 0x0001, 1997 .in_cables = 0x0001 1998 } 1999 } 2000 }, 2001 { 2002 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 2003 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2004 .vendor_name = "M-Audio", 2005 .product_name = "OmniStudio", 2006 .ifnum = QUIRK_ANY_INTERFACE, 2007 .type = QUIRK_COMPOSITE, 2008 .data = & (const struct snd_usb_audio_quirk[]) { 2009 { 2010 .ifnum = 0, 2011 .type = QUIRK_IGNORE_INTERFACE 2012 }, 2013 { 2014 .ifnum = 1, 2015 .type = QUIRK_IGNORE_INTERFACE 2016 }, 2017 { 2018 .ifnum = 2, 2019 .type = QUIRK_IGNORE_INTERFACE 2020 }, 2021 { 2022 .ifnum = 3, 2023 .type = QUIRK_IGNORE_INTERFACE 2024 }, 2025 { 2026 .ifnum = 4, 2027 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2028 }, 2029 { 2030 .ifnum = 5, 2031 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2032 }, 2033 { 2034 .ifnum = 6, 2035 .type = QUIRK_IGNORE_INTERFACE 2036 }, 2037 { 2038 .ifnum = 7, 2039 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2040 }, 2041 { 2042 .ifnum = 8, 2043 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2044 }, 2045 { 2046 .ifnum = 9, 2047 .type = QUIRK_MIDI_MIDIMAN, 2048 .data = & (const struct snd_usb_midi_endpoint_info) { 2049 .out_cables = 0x0001, 2050 .in_cables = 0x0001 2051 } 2052 }, 2053 { 2054 .ifnum = -1 2055 } 2056 } 2057 } 2058 }, 2059 { 2060 USB_DEVICE(0x0763, 0x2019), 2061 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2062 /* .vendor_name = "M-Audio", */ 2063 /* .product_name = "Ozone Academic", */ 2064 .ifnum = QUIRK_ANY_INTERFACE, 2065 .type = QUIRK_COMPOSITE, 2066 .data = & (const struct snd_usb_audio_quirk[]) { 2067 { 2068 .ifnum = 0, 2069 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2070 }, 2071 { 2072 .ifnum = 1, 2073 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2074 }, 2075 { 2076 .ifnum = 2, 2077 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2078 }, 2079 { 2080 .ifnum = 3, 2081 .type = QUIRK_MIDI_MIDIMAN, 2082 .data = & (const struct snd_usb_midi_endpoint_info) { 2083 .out_cables = 0x0001, 2084 .in_cables = 0x0001 2085 } 2086 }, 2087 { 2088 .ifnum = -1 2089 } 2090 } 2091 } 2092 }, 2093 { 2094 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030), 2095 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2096 /* .vendor_name = "M-Audio", */ 2097 /* .product_name = "Fast Track C400", */ 2098 .ifnum = QUIRK_ANY_INTERFACE, 2099 .type = QUIRK_COMPOSITE, 2100 .data = &(const struct snd_usb_audio_quirk[]) { 2101 { 2102 .ifnum = 1, 2103 .type = QUIRK_AUDIO_STANDARD_MIXER, 2104 }, 2105 /* Playback */ 2106 { 2107 .ifnum = 2, 2108 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2109 .data = &(const struct audioformat) { 2110 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2111 .channels = 6, 2112 .iface = 2, 2113 .altsetting = 1, 2114 .altset_idx = 1, 2115 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2116 .endpoint = 0x01, 2117 .ep_attr = 0x09, 2118 .rates = SNDRV_PCM_RATE_44100 | 2119 SNDRV_PCM_RATE_48000 | 2120 SNDRV_PCM_RATE_88200 | 2121 SNDRV_PCM_RATE_96000, 2122 .rate_min = 44100, 2123 .rate_max = 96000, 2124 .nr_rates = 4, 2125 .rate_table = (unsigned int[]) { 2126 44100, 48000, 88200, 96000 2127 }, 2128 .clock = 0x80, 2129 } 2130 }, 2131 /* Capture */ 2132 { 2133 .ifnum = 3, 2134 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2135 .data = &(const struct audioformat) { 2136 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2137 .channels = 4, 2138 .iface = 3, 2139 .altsetting = 1, 2140 .altset_idx = 1, 2141 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2142 .endpoint = 0x81, 2143 .ep_attr = 0x05, 2144 .rates = SNDRV_PCM_RATE_44100 | 2145 SNDRV_PCM_RATE_48000 | 2146 SNDRV_PCM_RATE_88200 | 2147 SNDRV_PCM_RATE_96000, 2148 .rate_min = 44100, 2149 .rate_max = 96000, 2150 .nr_rates = 4, 2151 .rate_table = (unsigned int[]) { 2152 44100, 48000, 88200, 96000 2153 }, 2154 .clock = 0x80, 2155 } 2156 }, 2157 /* MIDI */ 2158 { 2159 .ifnum = -1 /* Interface = 4 */ 2160 } 2161 } 2162 } 2163 }, 2164 { 2165 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031), 2166 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2167 /* .vendor_name = "M-Audio", */ 2168 /* .product_name = "Fast Track C600", */ 2169 .ifnum = QUIRK_ANY_INTERFACE, 2170 .type = QUIRK_COMPOSITE, 2171 .data = &(const struct snd_usb_audio_quirk[]) { 2172 { 2173 .ifnum = 1, 2174 .type = QUIRK_AUDIO_STANDARD_MIXER, 2175 }, 2176 /* Playback */ 2177 { 2178 .ifnum = 2, 2179 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2180 .data = &(const struct audioformat) { 2181 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2182 .channels = 8, 2183 .iface = 2, 2184 .altsetting = 1, 2185 .altset_idx = 1, 2186 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2187 .endpoint = 0x01, 2188 .ep_attr = 0x09, 2189 .rates = SNDRV_PCM_RATE_44100 | 2190 SNDRV_PCM_RATE_48000 | 2191 SNDRV_PCM_RATE_88200 | 2192 SNDRV_PCM_RATE_96000, 2193 .rate_min = 44100, 2194 .rate_max = 96000, 2195 .nr_rates = 4, 2196 .rate_table = (unsigned int[]) { 2197 44100, 48000, 88200, 96000 2198 }, 2199 .clock = 0x80, 2200 } 2201 }, 2202 /* Capture */ 2203 { 2204 .ifnum = 3, 2205 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2206 .data = &(const struct audioformat) { 2207 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2208 .channels = 6, 2209 .iface = 3, 2210 .altsetting = 1, 2211 .altset_idx = 1, 2212 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2213 .endpoint = 0x81, 2214 .ep_attr = 0x05, 2215 .rates = SNDRV_PCM_RATE_44100 | 2216 SNDRV_PCM_RATE_48000 | 2217 SNDRV_PCM_RATE_88200 | 2218 SNDRV_PCM_RATE_96000, 2219 .rate_min = 44100, 2220 .rate_max = 96000, 2221 .nr_rates = 4, 2222 .rate_table = (unsigned int[]) { 2223 44100, 48000, 88200, 96000 2224 }, 2225 .clock = 0x80, 2226 } 2227 }, 2228 /* MIDI */ 2229 { 2230 .ifnum = -1 /* Interface = 4 */ 2231 } 2232 } 2233 } 2234 }, 2235 { 2236 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080), 2237 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2238 /* .vendor_name = "M-Audio", */ 2239 /* .product_name = "Fast Track Ultra", */ 2240 .ifnum = QUIRK_ANY_INTERFACE, 2241 .type = QUIRK_COMPOSITE, 2242 .data = & (const struct snd_usb_audio_quirk[]) { 2243 { 2244 .ifnum = 0, 2245 .type = QUIRK_AUDIO_STANDARD_MIXER, 2246 }, 2247 { 2248 .ifnum = 1, 2249 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2250 .data = & (const struct audioformat) { 2251 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2252 .channels = 8, 2253 .iface = 1, 2254 .altsetting = 1, 2255 .altset_idx = 1, 2256 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2257 .endpoint = 0x01, 2258 .ep_attr = 0x09, 2259 .rates = SNDRV_PCM_RATE_44100 | 2260 SNDRV_PCM_RATE_48000 | 2261 SNDRV_PCM_RATE_88200 | 2262 SNDRV_PCM_RATE_96000, 2263 .rate_min = 44100, 2264 .rate_max = 96000, 2265 .nr_rates = 4, 2266 .rate_table = (unsigned int[]) { 2267 44100, 48000, 88200, 96000 2268 } 2269 } 2270 }, 2271 { 2272 .ifnum = 2, 2273 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2274 .data = & (const struct audioformat) { 2275 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2276 .channels = 8, 2277 .iface = 2, 2278 .altsetting = 1, 2279 .altset_idx = 1, 2280 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2281 .endpoint = 0x81, 2282 .ep_attr = 0x05, 2283 .rates = SNDRV_PCM_RATE_44100 | 2284 SNDRV_PCM_RATE_48000 | 2285 SNDRV_PCM_RATE_88200 | 2286 SNDRV_PCM_RATE_96000, 2287 .rate_min = 44100, 2288 .rate_max = 96000, 2289 .nr_rates = 4, 2290 .rate_table = (unsigned int[]) { 2291 44100, 48000, 88200, 96000 2292 } 2293 } 2294 }, 2295 /* interface 3 (MIDI) is standard compliant */ 2296 { 2297 .ifnum = -1 2298 } 2299 } 2300 } 2301 }, 2302 { 2303 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2304 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2305 /* .vendor_name = "M-Audio", */ 2306 /* .product_name = "Fast Track Ultra 8R", */ 2307 .ifnum = QUIRK_ANY_INTERFACE, 2308 .type = QUIRK_COMPOSITE, 2309 .data = & (const struct snd_usb_audio_quirk[]) { 2310 { 2311 .ifnum = 0, 2312 .type = QUIRK_AUDIO_STANDARD_MIXER, 2313 }, 2314 { 2315 .ifnum = 1, 2316 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2317 .data = & (const struct audioformat) { 2318 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2319 .channels = 8, 2320 .iface = 1, 2321 .altsetting = 1, 2322 .altset_idx = 1, 2323 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2324 .endpoint = 0x01, 2325 .ep_attr = 0x09, 2326 .rates = SNDRV_PCM_RATE_44100 | 2327 SNDRV_PCM_RATE_48000 | 2328 SNDRV_PCM_RATE_88200 | 2329 SNDRV_PCM_RATE_96000, 2330 .rate_min = 44100, 2331 .rate_max = 96000, 2332 .nr_rates = 4, 2333 .rate_table = (unsigned int[]) { 2334 44100, 48000, 88200, 96000 2335 } 2336 } 2337 }, 2338 { 2339 .ifnum = 2, 2340 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2341 .data = & (const struct audioformat) { 2342 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2343 .channels = 8, 2344 .iface = 2, 2345 .altsetting = 1, 2346 .altset_idx = 1, 2347 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2348 .endpoint = 0x81, 2349 .ep_attr = 0x05, 2350 .rates = SNDRV_PCM_RATE_44100 | 2351 SNDRV_PCM_RATE_48000 | 2352 SNDRV_PCM_RATE_88200 | 2353 SNDRV_PCM_RATE_96000, 2354 .rate_min = 44100, 2355 .rate_max = 96000, 2356 .nr_rates = 4, 2357 .rate_table = (unsigned int[]) { 2358 44100, 48000, 88200, 96000 2359 } 2360 } 2361 }, 2362 /* interface 3 (MIDI) is standard compliant */ 2363 { 2364 .ifnum = -1 2365 } 2366 } 2367 } 2368 }, 2369 2370 /* Casio devices */ 2371 { 2372 USB_DEVICE(0x07cf, 0x6801), 2373 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2374 .vendor_name = "Casio", 2375 .product_name = "PL-40R", 2376 .ifnum = 0, 2377 .type = QUIRK_MIDI_YAMAHA 2378 } 2379 }, 2380 { 2381 /* this ID is used by several devices without a product ID */ 2382 USB_DEVICE(0x07cf, 0x6802), 2383 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2384 .vendor_name = "Casio", 2385 .product_name = "Keyboard", 2386 .ifnum = 0, 2387 .type = QUIRK_MIDI_YAMAHA 2388 } 2389 }, 2390 2391 /* Mark of the Unicorn devices */ 2392 { 2393 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2394 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2395 USB_DEVICE_ID_MATCH_PRODUCT | 2396 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2397 .idVendor = 0x07fd, 2398 .idProduct = 0x0001, 2399 .bDeviceSubClass = 2, 2400 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2401 .vendor_name = "MOTU", 2402 .product_name = "Fastlane", 2403 .ifnum = QUIRK_ANY_INTERFACE, 2404 .type = QUIRK_COMPOSITE, 2405 .data = & (const struct snd_usb_audio_quirk[]) { 2406 { 2407 .ifnum = 0, 2408 .type = QUIRK_MIDI_RAW_BYTES 2409 }, 2410 { 2411 .ifnum = 1, 2412 .type = QUIRK_IGNORE_INTERFACE 2413 }, 2414 { 2415 .ifnum = -1 2416 } 2417 } 2418 } 2419 }, 2420 2421 /* Emagic devices */ 2422 { 2423 USB_DEVICE(0x086a, 0x0001), 2424 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2425 .vendor_name = "Emagic", 2426 .product_name = "Unitor8", 2427 .ifnum = 2, 2428 .type = QUIRK_MIDI_EMAGIC, 2429 .data = & (const struct snd_usb_midi_endpoint_info) { 2430 .out_cables = 0x80ff, 2431 .in_cables = 0x80ff 2432 } 2433 } 2434 }, 2435 { 2436 USB_DEVICE(0x086a, 0x0002), 2437 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2438 .vendor_name = "Emagic", 2439 /* .product_name = "AMT8", */ 2440 .ifnum = 2, 2441 .type = QUIRK_MIDI_EMAGIC, 2442 .data = & (const struct snd_usb_midi_endpoint_info) { 2443 .out_cables = 0x80ff, 2444 .in_cables = 0x80ff 2445 } 2446 } 2447 }, 2448 { 2449 USB_DEVICE(0x086a, 0x0003), 2450 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2451 .vendor_name = "Emagic", 2452 /* .product_name = "MT4", */ 2453 .ifnum = 2, 2454 .type = QUIRK_MIDI_EMAGIC, 2455 .data = & (const struct snd_usb_midi_endpoint_info) { 2456 .out_cables = 0x800f, 2457 .in_cables = 0x8003 2458 } 2459 } 2460 }, 2461 2462 /* KORG devices */ 2463 { 2464 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2465 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2466 .vendor_name = "KORG, Inc.", 2467 /* .product_name = "PANDORA PX5D", */ 2468 .ifnum = 3, 2469 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2470 } 2471 }, 2472 2473 { 2474 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201), 2475 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2476 .vendor_name = "KORG, Inc.", 2477 /* .product_name = "ToneLab ST", */ 2478 .ifnum = 3, 2479 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2480 } 2481 }, 2482 2483 /* AKAI devices */ 2484 { 2485 USB_DEVICE(0x09e8, 0x0062), 2486 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2487 .vendor_name = "AKAI", 2488 .product_name = "MPD16", 2489 .ifnum = 0, 2490 .type = QUIRK_MIDI_AKAI, 2491 } 2492 }, 2493 2494 { 2495 /* Akai MPC Element */ 2496 USB_DEVICE(0x09e8, 0x0021), 2497 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2498 .ifnum = QUIRK_ANY_INTERFACE, 2499 .type = QUIRK_COMPOSITE, 2500 .data = & (const struct snd_usb_audio_quirk[]) { 2501 { 2502 .ifnum = 0, 2503 .type = QUIRK_IGNORE_INTERFACE 2504 }, 2505 { 2506 .ifnum = 1, 2507 .type = QUIRK_MIDI_STANDARD_INTERFACE 2508 }, 2509 { 2510 .ifnum = -1 2511 } 2512 } 2513 } 2514 }, 2515 2516 /* Steinberg devices */ 2517 { 2518 /* Steinberg MI2 */ 2519 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040), 2520 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2521 .ifnum = QUIRK_ANY_INTERFACE, 2522 .type = QUIRK_COMPOSITE, 2523 .data = & (const struct snd_usb_audio_quirk[]) { 2524 { 2525 .ifnum = 0, 2526 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2527 }, 2528 { 2529 .ifnum = 1, 2530 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2531 }, 2532 { 2533 .ifnum = 2, 2534 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2535 }, 2536 { 2537 .ifnum = 3, 2538 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2539 .data = &(const struct snd_usb_midi_endpoint_info) { 2540 .out_cables = 0x0001, 2541 .in_cables = 0x0001 2542 } 2543 }, 2544 { 2545 .ifnum = -1 2546 } 2547 } 2548 } 2549 }, 2550 { 2551 /* Steinberg MI4 */ 2552 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040), 2553 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2554 .ifnum = QUIRK_ANY_INTERFACE, 2555 .type = QUIRK_COMPOSITE, 2556 .data = & (const struct snd_usb_audio_quirk[]) { 2557 { 2558 .ifnum = 0, 2559 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2560 }, 2561 { 2562 .ifnum = 1, 2563 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2564 }, 2565 { 2566 .ifnum = 2, 2567 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2568 }, 2569 { 2570 .ifnum = 3, 2571 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2572 .data = &(const struct snd_usb_midi_endpoint_info) { 2573 .out_cables = 0x0001, 2574 .in_cables = 0x0001 2575 } 2576 }, 2577 { 2578 .ifnum = -1 2579 } 2580 } 2581 } 2582 }, 2583 2584 /* TerraTec devices */ 2585 { 2586 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2587 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2588 .vendor_name = "TerraTec", 2589 .product_name = "PHASE 26", 2590 .ifnum = 3, 2591 .type = QUIRK_MIDI_STANDARD_INTERFACE 2592 } 2593 }, 2594 { 2595 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2596 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2597 .vendor_name = "TerraTec", 2598 .product_name = "PHASE 26", 2599 .ifnum = 3, 2600 .type = QUIRK_MIDI_STANDARD_INTERFACE 2601 } 2602 }, 2603 { 2604 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2605 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2606 .vendor_name = "TerraTec", 2607 .product_name = "PHASE 26", 2608 .ifnum = 3, 2609 .type = QUIRK_MIDI_STANDARD_INTERFACE 2610 } 2611 }, 2612 { 2613 USB_DEVICE(0x0ccd, 0x0028), 2614 QUIRK_RENAME_DEVICE("TerraTec", "Aureon5.1MkII") 2615 }, 2616 { 2617 USB_DEVICE(0x0ccd, 0x0035), 2618 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2619 .vendor_name = "Miditech", 2620 .product_name = "Play'n Roll", 2621 .ifnum = 0, 2622 .type = QUIRK_MIDI_CME 2623 } 2624 }, 2625 2626 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ 2627 { 2628 USB_DEVICE(0x103d, 0x0100), 2629 QUIRK_RENAME_DEVICE("Stanton", "ScratchAmp") 2630 }, 2631 { 2632 USB_DEVICE(0x103d, 0x0101), 2633 QUIRK_RENAME_DEVICE("Stanton", "ScratchAmp") 2634 }, 2635 2636 /* Novation EMS devices */ 2637 { 2638 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2639 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2640 .vendor_name = "Novation", 2641 .product_name = "ReMOTE Audio/XStation", 2642 .ifnum = 4, 2643 .type = QUIRK_MIDI_NOVATION 2644 } 2645 }, 2646 { 2647 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2648 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2649 .vendor_name = "Novation", 2650 .product_name = "Speedio", 2651 .ifnum = 3, 2652 .type = QUIRK_MIDI_NOVATION 2653 } 2654 }, 2655 { 2656 USB_DEVICE(0x1235, 0x000a), 2657 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2658 /* .vendor_name = "Novation", */ 2659 /* .product_name = "Nocturn", */ 2660 .ifnum = 0, 2661 .type = QUIRK_MIDI_RAW_BYTES 2662 } 2663 }, 2664 { 2665 USB_DEVICE(0x1235, 0x000e), 2666 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2667 /* .vendor_name = "Novation", */ 2668 /* .product_name = "Launchpad", */ 2669 .ifnum = 0, 2670 .type = QUIRK_MIDI_RAW_BYTES 2671 } 2672 }, 2673 { 2674 USB_DEVICE(0x1235, 0x0010), 2675 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2676 .vendor_name = "Focusrite", 2677 .product_name = "Saffire 6 USB", 2678 .ifnum = QUIRK_ANY_INTERFACE, 2679 .type = QUIRK_COMPOSITE, 2680 .data = (const struct snd_usb_audio_quirk[]) { 2681 { 2682 .ifnum = 0, 2683 .type = QUIRK_AUDIO_STANDARD_MIXER, 2684 }, 2685 { 2686 .ifnum = 0, 2687 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2688 .data = &(const struct audioformat) { 2689 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2690 .channels = 4, 2691 .iface = 0, 2692 .altsetting = 1, 2693 .altset_idx = 1, 2694 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2695 .endpoint = 0x01, 2696 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2697 .datainterval = 1, 2698 .maxpacksize = 0x024c, 2699 .rates = SNDRV_PCM_RATE_44100 | 2700 SNDRV_PCM_RATE_48000, 2701 .rate_min = 44100, 2702 .rate_max = 48000, 2703 .nr_rates = 2, 2704 .rate_table = (unsigned int[]) { 2705 44100, 48000 2706 } 2707 } 2708 }, 2709 { 2710 .ifnum = 0, 2711 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2712 .data = &(const struct audioformat) { 2713 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2714 .channels = 2, 2715 .iface = 0, 2716 .altsetting = 1, 2717 .altset_idx = 1, 2718 .attributes = 0, 2719 .endpoint = 0x82, 2720 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2721 .datainterval = 1, 2722 .maxpacksize = 0x0126, 2723 .rates = SNDRV_PCM_RATE_44100 | 2724 SNDRV_PCM_RATE_48000, 2725 .rate_min = 44100, 2726 .rate_max = 48000, 2727 .nr_rates = 2, 2728 .rate_table = (unsigned int[]) { 2729 44100, 48000 2730 } 2731 } 2732 }, 2733 { 2734 .ifnum = 1, 2735 .type = QUIRK_MIDI_RAW_BYTES 2736 }, 2737 { 2738 .ifnum = -1 2739 } 2740 } 2741 } 2742 }, 2743 { 2744 USB_DEVICE(0x1235, 0x0018), 2745 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2746 .vendor_name = "Novation", 2747 .product_name = "Twitch", 2748 .ifnum = QUIRK_ANY_INTERFACE, 2749 .type = QUIRK_COMPOSITE, 2750 .data = (const struct snd_usb_audio_quirk[]) { 2751 { 2752 .ifnum = 0, 2753 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2754 .data = & (const struct audioformat) { 2755 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2756 .channels = 4, 2757 .iface = 0, 2758 .altsetting = 1, 2759 .altset_idx = 1, 2760 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2761 .endpoint = 0x01, 2762 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2763 .rates = SNDRV_PCM_RATE_44100 | 2764 SNDRV_PCM_RATE_48000, 2765 .rate_min = 44100, 2766 .rate_max = 48000, 2767 .nr_rates = 2, 2768 .rate_table = (unsigned int[]) { 2769 44100, 48000 2770 } 2771 } 2772 }, 2773 { 2774 .ifnum = 1, 2775 .type = QUIRK_MIDI_RAW_BYTES 2776 }, 2777 { 2778 .ifnum = -1 2779 } 2780 } 2781 } 2782 }, 2783 { 2784 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2785 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2786 .vendor_name = "Novation", 2787 .product_name = "ReMOTE25", 2788 .ifnum = 0, 2789 .type = QUIRK_MIDI_NOVATION 2790 } 2791 }, 2792 2793 /* Access Music devices */ 2794 { 2795 /* VirusTI Desktop */ 2796 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2797 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2798 .ifnum = QUIRK_ANY_INTERFACE, 2799 .type = QUIRK_COMPOSITE, 2800 .data = &(const struct snd_usb_audio_quirk[]) { 2801 { 2802 .ifnum = 3, 2803 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2804 .data = &(const struct snd_usb_midi_endpoint_info) { 2805 .out_cables = 0x0003, 2806 .in_cables = 0x0003 2807 } 2808 }, 2809 { 2810 .ifnum = 4, 2811 .type = QUIRK_IGNORE_INTERFACE 2812 }, 2813 { 2814 .ifnum = -1 2815 } 2816 } 2817 } 2818 }, 2819 2820 /* */ 2821 { 2822 /* aka. Serato Scratch Live DJ Box */ 2823 USB_DEVICE(0x13e5, 0x0001), 2824 QUIRK_RENAME_DEVICE("Rane", "SL-1") 2825 }, 2826 2827 /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */ 2828 { 2829 USB_DEVICE(0x17aa, 0x1046), 2830 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2831 .vendor_name = "Lenovo", 2832 .product_name = "ThinkStation P620 Rear", 2833 .profile_name = "Lenovo-ThinkStation-P620-Rear", 2834 .ifnum = QUIRK_ANY_INTERFACE, 2835 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND 2836 } 2837 }, 2838 /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */ 2839 { 2840 USB_DEVICE(0x17aa, 0x104d), 2841 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2842 .vendor_name = "Lenovo", 2843 .product_name = "ThinkStation P620 Main", 2844 .profile_name = "Lenovo-ThinkStation-P620-Main", 2845 .ifnum = QUIRK_ANY_INTERFACE, 2846 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND 2847 } 2848 }, 2849 2850 /* Native Instruments MK2 series */ 2851 { 2852 /* Komplete Audio 6 */ 2853 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2854 .idVendor = 0x17cc, 2855 .idProduct = 0x1000, 2856 }, 2857 { 2858 /* Traktor Audio 6 */ 2859 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2860 .idVendor = 0x17cc, 2861 .idProduct = 0x1010, 2862 }, 2863 { 2864 /* Traktor Audio 10 */ 2865 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2866 .idVendor = 0x17cc, 2867 .idProduct = 0x1020, 2868 }, 2869 2870 /* QinHeng devices */ 2871 { 2872 USB_DEVICE(0x1a86, 0x752d), 2873 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2874 .vendor_name = "QinHeng", 2875 .product_name = "CH345", 2876 .ifnum = 1, 2877 .type = QUIRK_MIDI_CH345 2878 } 2879 }, 2880 2881 /* KeithMcMillen Stringport */ 2882 { 2883 USB_DEVICE(0x1f38, 0x0001), 2884 .bInterfaceClass = USB_CLASS_AUDIO, 2885 }, 2886 2887 /* Miditech devices */ 2888 { 2889 USB_DEVICE(0x4752, 0x0011), 2890 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2891 .vendor_name = "Miditech", 2892 .product_name = "Midistart-2", 2893 .ifnum = 0, 2894 .type = QUIRK_MIDI_CME 2895 } 2896 }, 2897 2898 /* Central Music devices */ 2899 { 2900 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2901 USB_DEVICE(0x7104, 0x2202), 2902 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2903 .ifnum = 0, 2904 .type = QUIRK_MIDI_CME 2905 } 2906 }, 2907 2908 /* 2909 * Auvitek au0828 devices with audio interface. 2910 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c 2911 * Please notice that some drivers are DVB only, and don't need to be 2912 * here. That's the case, for example, of DVICO_FUSIONHDTV7. 2913 */ 2914 2915 #define AU0828_DEVICE(vid, pid, vname, pname) { \ 2916 .idVendor = vid, \ 2917 .idProduct = pid, \ 2918 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ 2919 USB_DEVICE_ID_MATCH_INT_CLASS | \ 2920 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \ 2921 .bInterfaceClass = USB_CLASS_AUDIO, \ 2922 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \ 2923 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \ 2924 .vendor_name = vname, \ 2925 .product_name = pname, \ 2926 .ifnum = QUIRK_ANY_INTERFACE, \ 2927 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \ 2928 .shares_media_device = 1, \ 2929 } \ 2930 } 2931 2932 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"), 2933 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"), 2934 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"), 2935 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"), 2936 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"), 2937 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"), 2938 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"), 2939 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"), 2940 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"), 2941 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"), 2942 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"), 2943 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"), 2944 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"), 2945 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"), 2946 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"), 2947 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"), 2948 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"), 2949 2950 /* Syntek STK1160 */ 2951 { 2952 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2953 USB_DEVICE_ID_MATCH_INT_CLASS | 2954 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2955 .idVendor = 0x05e1, 2956 .idProduct = 0x0408, 2957 .bInterfaceClass = USB_CLASS_AUDIO, 2958 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2959 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2960 .vendor_name = "Syntek", 2961 .product_name = "STK1160", 2962 .ifnum = QUIRK_ANY_INTERFACE, 2963 .type = QUIRK_AUDIO_ALIGN_TRANSFER 2964 } 2965 }, 2966 2967 /* Digidesign Mbox */ 2968 { 2969 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2970 USB_DEVICE(0x0dba, 0x1000), 2971 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2972 .vendor_name = "Digidesign", 2973 .product_name = "MBox", 2974 .ifnum = QUIRK_ANY_INTERFACE, 2975 .type = QUIRK_COMPOSITE, 2976 .data = (const struct snd_usb_audio_quirk[]){ 2977 { 2978 .ifnum = 0, 2979 .type = QUIRK_AUDIO_STANDARD_MIXER, 2980 }, 2981 { 2982 .ifnum = 1, 2983 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2984 .data = &(const struct audioformat) { 2985 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2986 .channels = 2, 2987 .iface = 1, 2988 .altsetting = 1, 2989 .altset_idx = 1, 2990 .attributes = 0x4, 2991 .endpoint = 0x02, 2992 .ep_attr = USB_ENDPOINT_XFER_ISOC | 2993 USB_ENDPOINT_SYNC_SYNC, 2994 .maxpacksize = 0x130, 2995 .rates = SNDRV_PCM_RATE_48000, 2996 .rate_min = 48000, 2997 .rate_max = 48000, 2998 .nr_rates = 1, 2999 .rate_table = (unsigned int[]) { 3000 48000 3001 } 3002 } 3003 }, 3004 { 3005 .ifnum = 1, 3006 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3007 .data = &(const struct audioformat) { 3008 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3009 .channels = 2, 3010 .iface = 1, 3011 .altsetting = 1, 3012 .altset_idx = 1, 3013 .attributes = 0x4, 3014 .endpoint = 0x81, 3015 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3016 USB_ENDPOINT_SYNC_ASYNC, 3017 .maxpacksize = 0x130, 3018 .rates = SNDRV_PCM_RATE_48000, 3019 .rate_min = 48000, 3020 .rate_max = 48000, 3021 .nr_rates = 1, 3022 .rate_table = (unsigned int[]) { 3023 48000 3024 } 3025 } 3026 }, 3027 { 3028 .ifnum = -1 3029 } 3030 } 3031 } 3032 }, 3033 3034 /* DIGIDESIGN MBOX 2 */ 3035 { 3036 USB_DEVICE(0x0dba, 0x3000), 3037 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3038 .vendor_name = "Digidesign", 3039 .product_name = "Mbox 2", 3040 .ifnum = QUIRK_ANY_INTERFACE, 3041 .type = QUIRK_COMPOSITE, 3042 .data = (const struct snd_usb_audio_quirk[]) { 3043 { 3044 .ifnum = 0, 3045 .type = QUIRK_IGNORE_INTERFACE 3046 }, 3047 { 3048 .ifnum = 1, 3049 .type = QUIRK_IGNORE_INTERFACE 3050 }, 3051 { 3052 .ifnum = 2, 3053 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3054 .data = &(const struct audioformat) { 3055 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3056 .channels = 2, 3057 .iface = 2, 3058 .altsetting = 2, 3059 .altset_idx = 1, 3060 .attributes = 0x00, 3061 .endpoint = 0x03, 3062 .ep_attr = USB_ENDPOINT_SYNC_ASYNC, 3063 .rates = SNDRV_PCM_RATE_48000, 3064 .rate_min = 48000, 3065 .rate_max = 48000, 3066 .nr_rates = 1, 3067 .rate_table = (unsigned int[]) { 3068 48000 3069 } 3070 } 3071 }, 3072 { 3073 .ifnum = 3, 3074 .type = QUIRK_IGNORE_INTERFACE 3075 }, 3076 { 3077 .ifnum = 4, 3078 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3079 .data = &(const struct audioformat) { 3080 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3081 .channels = 2, 3082 .iface = 4, 3083 .altsetting = 2, 3084 .altset_idx = 1, 3085 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3086 .endpoint = 0x85, 3087 .ep_attr = USB_ENDPOINT_SYNC_SYNC, 3088 .rates = SNDRV_PCM_RATE_48000, 3089 .rate_min = 48000, 3090 .rate_max = 48000, 3091 .nr_rates = 1, 3092 .rate_table = (unsigned int[]) { 3093 48000 3094 } 3095 } 3096 }, 3097 { 3098 .ifnum = 5, 3099 .type = QUIRK_IGNORE_INTERFACE 3100 }, 3101 { 3102 .ifnum = 6, 3103 .type = QUIRK_MIDI_MIDIMAN, 3104 .data = &(const struct snd_usb_midi_endpoint_info) { 3105 .out_ep = 0x02, 3106 .out_cables = 0x0001, 3107 .in_ep = 0x81, 3108 .in_interval = 0x01, 3109 .in_cables = 0x0001 3110 } 3111 }, 3112 { 3113 .ifnum = -1 3114 } 3115 } 3116 } 3117 }, 3118 { 3119 /* Tascam US122 MKII - playback-only support */ 3120 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 3121 .idVendor = 0x0644, 3122 .idProduct = 0x8021, 3123 .bInterfaceClass = USB_CLASS_AUDIO, 3124 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3125 .vendor_name = "TASCAM", 3126 .product_name = "US122 MKII", 3127 .ifnum = QUIRK_ANY_INTERFACE, 3128 .type = QUIRK_COMPOSITE, 3129 .data = (const struct snd_usb_audio_quirk[]) { 3130 { 3131 .ifnum = 0, 3132 .type = QUIRK_IGNORE_INTERFACE 3133 }, 3134 { 3135 .ifnum = 1, 3136 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3137 .data = &(const struct audioformat) { 3138 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3139 .channels = 2, 3140 .iface = 1, 3141 .altsetting = 1, 3142 .altset_idx = 1, 3143 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3144 .endpoint = 0x02, 3145 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3146 .rates = SNDRV_PCM_RATE_44100 | 3147 SNDRV_PCM_RATE_48000 | 3148 SNDRV_PCM_RATE_88200 | 3149 SNDRV_PCM_RATE_96000, 3150 .rate_min = 44100, 3151 .rate_max = 96000, 3152 .nr_rates = 4, 3153 .rate_table = (unsigned int[]) { 3154 44100, 48000, 88200, 96000 3155 } 3156 } 3157 }, 3158 { 3159 .ifnum = -1 3160 } 3161 } 3162 } 3163 }, 3164 3165 /* Microsoft XboxLive Headset/Xbox Communicator */ 3166 { 3167 USB_DEVICE(0x045e, 0x0283), 3168 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3169 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3170 .vendor_name = "Microsoft", 3171 .product_name = "XboxLive Headset/Xbox Communicator", 3172 .ifnum = QUIRK_ANY_INTERFACE, 3173 .type = QUIRK_COMPOSITE, 3174 .data = &(const struct snd_usb_audio_quirk[]) { 3175 { 3176 /* playback */ 3177 .ifnum = 0, 3178 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3179 .data = &(const struct audioformat) { 3180 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3181 .channels = 1, 3182 .iface = 0, 3183 .altsetting = 0, 3184 .altset_idx = 0, 3185 .attributes = 0, 3186 .endpoint = 0x04, 3187 .ep_attr = 0x05, 3188 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3189 .rate_min = 22050, 3190 .rate_max = 22050 3191 } 3192 }, 3193 { 3194 /* capture */ 3195 .ifnum = 1, 3196 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3197 .data = &(const struct audioformat) { 3198 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3199 .channels = 1, 3200 .iface = 1, 3201 .altsetting = 0, 3202 .altset_idx = 0, 3203 .attributes = 0, 3204 .endpoint = 0x85, 3205 .ep_attr = 0x05, 3206 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3207 .rate_min = 16000, 3208 .rate_max = 16000 3209 } 3210 }, 3211 { 3212 .ifnum = -1 3213 } 3214 } 3215 } 3216 }, 3217 3218 /* Reloop Play */ 3219 { 3220 USB_DEVICE(0x200c, 0x100b), 3221 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3222 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3223 .ifnum = QUIRK_ANY_INTERFACE, 3224 .type = QUIRK_COMPOSITE, 3225 .data = &(const struct snd_usb_audio_quirk[]) { 3226 { 3227 .ifnum = 0, 3228 .type = QUIRK_AUDIO_STANDARD_MIXER, 3229 }, 3230 { 3231 .ifnum = 1, 3232 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3233 .data = &(const struct audioformat) { 3234 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3235 .channels = 4, 3236 .iface = 1, 3237 .altsetting = 1, 3238 .altset_idx = 1, 3239 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3240 .endpoint = 0x01, 3241 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE, 3242 .rates = SNDRV_PCM_RATE_44100 | 3243 SNDRV_PCM_RATE_48000, 3244 .rate_min = 44100, 3245 .rate_max = 48000, 3246 .nr_rates = 2, 3247 .rate_table = (unsigned int[]) { 3248 44100, 48000 3249 } 3250 } 3251 }, 3252 { 3253 .ifnum = -1 3254 } 3255 } 3256 } 3257 }, 3258 3259 { 3260 /* 3261 * ZOOM R16/24 in audio interface mode. 3262 * Playback requires an extra four byte LE length indicator 3263 * at the start of each isochronous packet. This quirk is 3264 * enabled in create_standard_audio_quirk(). 3265 */ 3266 USB_DEVICE(0x1686, 0x00dd), 3267 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3268 .ifnum = QUIRK_ANY_INTERFACE, 3269 .type = QUIRK_COMPOSITE, 3270 .data = (const struct snd_usb_audio_quirk[]) { 3271 { 3272 /* Playback */ 3273 .ifnum = 1, 3274 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 3275 }, 3276 { 3277 /* Capture */ 3278 .ifnum = 2, 3279 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 3280 }, 3281 { 3282 /* Midi */ 3283 .ifnum = 3, 3284 .type = QUIRK_MIDI_STANDARD_INTERFACE 3285 }, 3286 { 3287 .ifnum = -1 3288 }, 3289 } 3290 } 3291 }, 3292 3293 { 3294 /* 3295 * Some USB MIDI devices don't have an audio control interface, 3296 * so we have to grab MIDI streaming interfaces here. 3297 */ 3298 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 3299 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 3300 .bInterfaceClass = USB_CLASS_AUDIO, 3301 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 3302 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3303 .ifnum = QUIRK_ANY_INTERFACE, 3304 .type = QUIRK_MIDI_STANDARD_INTERFACE 3305 } 3306 }, 3307 3308 /* 3309 * The original product_name is "USB Sound Device", however this name 3310 * is also used by the CM106 based cards, so make it unique. 3311 */ 3312 { 3313 USB_DEVICE(0x0d8c, 0x0102), 3314 QUIRK_RENAME_DEVICE(NULL, "ICUSBAUDIO7D") 3315 }, 3316 { 3317 USB_DEVICE(0x0d8c, 0x0103), 3318 QUIRK_RENAME_DEVICE(NULL, "Audio Advantage MicroII") 3319 }, 3320 3321 /* disabled due to regression for other devices; 3322 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905 3323 */ 3324 #if 0 3325 { 3326 /* 3327 * Nura's first gen headphones use Cambridge Silicon Radio's vendor 3328 * ID, but it looks like the product ID actually is only for Nura. 3329 * The capture interface does not work at all (even on Windows), 3330 * and only the 48 kHz sample rate works for the playback interface. 3331 */ 3332 USB_DEVICE(0x0a12, 0x1243), 3333 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3334 .ifnum = QUIRK_ANY_INTERFACE, 3335 .type = QUIRK_COMPOSITE, 3336 .data = (const struct snd_usb_audio_quirk[]) { 3337 { 3338 .ifnum = 0, 3339 .type = QUIRK_AUDIO_STANDARD_MIXER, 3340 }, 3341 /* Capture */ 3342 { 3343 .ifnum = 1, 3344 .type = QUIRK_IGNORE_INTERFACE, 3345 }, 3346 /* Playback */ 3347 { 3348 .ifnum = 2, 3349 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3350 .data = &(const struct audioformat) { 3351 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3352 .channels = 2, 3353 .iface = 2, 3354 .altsetting = 1, 3355 .altset_idx = 1, 3356 .attributes = UAC_EP_CS_ATTR_FILL_MAX | 3357 UAC_EP_CS_ATTR_SAMPLE_RATE, 3358 .endpoint = 0x03, 3359 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3360 .rates = SNDRV_PCM_RATE_48000, 3361 .rate_min = 48000, 3362 .rate_max = 48000, 3363 .nr_rates = 1, 3364 .rate_table = (unsigned int[]) { 3365 48000 3366 } 3367 } 3368 }, 3369 { 3370 .ifnum = -1 3371 }, 3372 } 3373 } 3374 }, 3375 #endif /* disabled */ 3376 3377 { 3378 /* 3379 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate 3380 * even though it advertises more. The capture interface doesn't work 3381 * even on windows. 3382 */ 3383 USB_DEVICE(0x19b5, 0x0021), 3384 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3385 .ifnum = QUIRK_ANY_INTERFACE, 3386 .type = QUIRK_COMPOSITE, 3387 .data = (const struct snd_usb_audio_quirk[]) { 3388 { 3389 .ifnum = 0, 3390 .type = QUIRK_AUDIO_STANDARD_MIXER, 3391 }, 3392 /* Playback */ 3393 { 3394 .ifnum = 1, 3395 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3396 .data = &(const struct audioformat) { 3397 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3398 .channels = 2, 3399 .iface = 1, 3400 .altsetting = 1, 3401 .altset_idx = 1, 3402 .attributes = UAC_EP_CS_ATTR_FILL_MAX | 3403 UAC_EP_CS_ATTR_SAMPLE_RATE, 3404 .endpoint = 0x03, 3405 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3406 .rates = SNDRV_PCM_RATE_48000, 3407 .rate_min = 48000, 3408 .rate_max = 48000, 3409 .nr_rates = 1, 3410 .rate_table = (unsigned int[]) { 3411 48000 3412 } 3413 } 3414 }, 3415 { 3416 .ifnum = -1 3417 }, 3418 } 3419 } 3420 }, 3421 /* Dell WD15 Dock */ 3422 { 3423 USB_DEVICE(0x0bda, 0x4014), 3424 QUIRK_DEVICE_PROFILE("Dell", "WD15 Dock", "Dell-WD15-Dock") 3425 }, 3426 /* Dell WD19 Dock */ 3427 { 3428 USB_DEVICE(0x0bda, 0x402e), 3429 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3430 .vendor_name = "Dell", 3431 .product_name = "WD19 Dock", 3432 .profile_name = "Dell-WD15-Dock", 3433 .ifnum = QUIRK_ANY_INTERFACE, 3434 .type = QUIRK_SETUP_FMT_AFTER_RESUME 3435 } 3436 }, 3437 /* MOTU Microbook II */ 3438 { 3439 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004), 3440 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3441 .vendor_name = "MOTU", 3442 .product_name = "MicroBookII", 3443 .ifnum = QUIRK_ANY_INTERFACE, 3444 .type = QUIRK_COMPOSITE, 3445 .data = (const struct snd_usb_audio_quirk[]) { 3446 { 3447 .ifnum = 0, 3448 .type = QUIRK_AUDIO_STANDARD_MIXER, 3449 }, 3450 { 3451 .ifnum = 0, 3452 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3453 .data = &(const struct audioformat) { 3454 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3455 .channels = 6, 3456 .iface = 0, 3457 .altsetting = 1, 3458 .altset_idx = 1, 3459 .attributes = 0, 3460 .endpoint = 0x84, 3461 .rates = SNDRV_PCM_RATE_96000, 3462 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3463 USB_ENDPOINT_SYNC_ASYNC, 3464 .rate_min = 96000, 3465 .rate_max = 96000, 3466 .nr_rates = 1, 3467 .maxpacksize = 0x00d8, 3468 .rate_table = (unsigned int[]) { 3469 96000 3470 } 3471 } 3472 }, 3473 { 3474 .ifnum = 0, 3475 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3476 .data = &(const struct audioformat) { 3477 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3478 .channels = 8, 3479 .iface = 0, 3480 .altsetting = 1, 3481 .altset_idx = 1, 3482 .attributes = 0, 3483 .endpoint = 0x03, 3484 .rates = SNDRV_PCM_RATE_96000, 3485 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3486 USB_ENDPOINT_SYNC_ASYNC, 3487 .rate_min = 96000, 3488 .rate_max = 96000, 3489 .nr_rates = 1, 3490 .maxpacksize = 0x0120, 3491 .rate_table = (unsigned int[]) { 3492 96000 3493 } 3494 } 3495 }, 3496 { 3497 .ifnum = -1 3498 } 3499 } 3500 } 3501 }, 3502 { 3503 /* 3504 * PIONEER DJ DDJ-SX3 3505 * PCM is 12 channels out, 10 channels in @ 44.1 fixed 3506 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86 3507 * The feedback for the output is the input. 3508 */ 3509 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023), 3510 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3511 .ifnum = QUIRK_ANY_INTERFACE, 3512 .type = QUIRK_COMPOSITE, 3513 .data = (const struct snd_usb_audio_quirk[]) { 3514 { 3515 .ifnum = 0, 3516 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3517 .data = &(const struct audioformat) { 3518 .formats = SNDRV_PCM_FMTBIT_S32_LE, 3519 .channels = 12, 3520 .iface = 0, 3521 .altsetting = 1, 3522 .altset_idx = 1, 3523 .endpoint = 0x05, 3524 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3525 USB_ENDPOINT_SYNC_ASYNC, 3526 .rates = SNDRV_PCM_RATE_44100, 3527 .rate_min = 44100, 3528 .rate_max = 44100, 3529 .nr_rates = 1, 3530 .rate_table = (unsigned int[]) { 44100 } 3531 } 3532 }, 3533 { 3534 .ifnum = 0, 3535 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3536 .data = &(const struct audioformat) { 3537 .formats = SNDRV_PCM_FMTBIT_S32_LE, 3538 .channels = 10, 3539 .iface = 0, 3540 .altsetting = 1, 3541 .altset_idx = 1, 3542 .endpoint = 0x86, 3543 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3544 USB_ENDPOINT_SYNC_ASYNC| 3545 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3546 .rates = SNDRV_PCM_RATE_44100, 3547 .rate_min = 44100, 3548 .rate_max = 44100, 3549 .nr_rates = 1, 3550 .rate_table = (unsigned int[]) { 44100 } 3551 } 3552 }, 3553 { 3554 .ifnum = -1 3555 } 3556 } 3557 } 3558 }, 3559 { 3560 /* 3561 * Pioneer DJ DJM-250MK2 3562 * PCM is 8 channels out @ 48 fixed (endpoint 0x01) 3563 * and 8 channels in @ 48 fixed (endpoint 0x82). 3564 * 3565 * Both playback and recording is working, even simultaneously. 3566 * 3567 * Playback channels could be mapped to: 3568 * - CH1 3569 * - CH2 3570 * - AUX 3571 * 3572 * Recording channels could be mapped to: 3573 * - Post CH1 Fader 3574 * - Post CH2 Fader 3575 * - Cross Fader A 3576 * - Cross Fader B 3577 * - MIC 3578 * - AUX 3579 * - REC OUT 3580 * 3581 * There is remaining problem with recording directly from PHONO/LINE. 3582 * If we map a channel to: 3583 * - CH1 Control Tone PHONO 3584 * - CH1 Control Tone LINE 3585 * - CH2 Control Tone PHONO 3586 * - CH2 Control Tone LINE 3587 * it is silent. 3588 * There is no signal even on other operating systems with official drivers. 3589 * The signal appears only when a supported application is started. 3590 * This needs to be investigated yet... 3591 * (there is quite a lot communication on the USB in both directions) 3592 * 3593 * In current version this mixer could be used for playback 3594 * and for recording from vinyls (through Post CH* Fader) 3595 * but not for DVS (Digital Vinyl Systems) like in Mixxx. 3596 */ 3597 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017), 3598 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3599 .ifnum = QUIRK_ANY_INTERFACE, 3600 .type = QUIRK_COMPOSITE, 3601 .data = (const struct snd_usb_audio_quirk[]) { 3602 { 3603 .ifnum = 0, 3604 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3605 .data = &(const struct audioformat) { 3606 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3607 .channels = 8, // outputs 3608 .iface = 0, 3609 .altsetting = 1, 3610 .altset_idx = 1, 3611 .endpoint = 0x01, 3612 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3613 USB_ENDPOINT_SYNC_ASYNC, 3614 .rates = SNDRV_PCM_RATE_48000, 3615 .rate_min = 48000, 3616 .rate_max = 48000, 3617 .nr_rates = 1, 3618 .rate_table = (unsigned int[]) { 48000 } 3619 } 3620 }, 3621 { 3622 .ifnum = 0, 3623 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3624 .data = &(const struct audioformat) { 3625 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3626 .channels = 8, // inputs 3627 .iface = 0, 3628 .altsetting = 1, 3629 .altset_idx = 1, 3630 .endpoint = 0x82, 3631 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3632 USB_ENDPOINT_SYNC_ASYNC| 3633 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3634 .rates = SNDRV_PCM_RATE_48000, 3635 .rate_min = 48000, 3636 .rate_max = 48000, 3637 .nr_rates = 1, 3638 .rate_table = (unsigned int[]) { 48000 } 3639 } 3640 }, 3641 { 3642 .ifnum = -1 3643 } 3644 } 3645 } 3646 }, 3647 { 3648 /* 3649 * PIONEER DJ DDJ-RB 3650 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed 3651 * The feedback for the output is the dummy input. 3652 */ 3653 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e), 3654 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3655 .ifnum = QUIRK_ANY_INTERFACE, 3656 .type = QUIRK_COMPOSITE, 3657 .data = (const struct snd_usb_audio_quirk[]) { 3658 { 3659 .ifnum = 0, 3660 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3661 .data = &(const struct audioformat) { 3662 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3663 .channels = 4, 3664 .iface = 0, 3665 .altsetting = 1, 3666 .altset_idx = 1, 3667 .endpoint = 0x01, 3668 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3669 USB_ENDPOINT_SYNC_ASYNC, 3670 .rates = SNDRV_PCM_RATE_44100, 3671 .rate_min = 44100, 3672 .rate_max = 44100, 3673 .nr_rates = 1, 3674 .rate_table = (unsigned int[]) { 44100 } 3675 } 3676 }, 3677 { 3678 .ifnum = 0, 3679 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3680 .data = &(const struct audioformat) { 3681 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3682 .channels = 2, 3683 .iface = 0, 3684 .altsetting = 1, 3685 .altset_idx = 1, 3686 .endpoint = 0x82, 3687 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3688 USB_ENDPOINT_SYNC_ASYNC| 3689 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3690 .rates = SNDRV_PCM_RATE_44100, 3691 .rate_min = 44100, 3692 .rate_max = 44100, 3693 .nr_rates = 1, 3694 .rate_table = (unsigned int[]) { 44100 } 3695 } 3696 }, 3697 { 3698 .ifnum = -1 3699 } 3700 } 3701 } 3702 }, 3703 3704 #define ALC1220_VB_DESKTOP(vend, prod) { \ 3705 USB_DEVICE(vend, prod), \ 3706 QUIRK_DEVICE_PROFILE("Realtek", "ALC1220-VB-DT", \ 3707 "Realtek-ALC1220-VB-Desktop") \ 3708 } 3709 ALC1220_VB_DESKTOP(0x0414, 0xa002), /* Gigabyte TRX40 Aorus Pro WiFi */ 3710 ALC1220_VB_DESKTOP(0x0db0, 0x0d64), /* MSI TRX40 Creator */ 3711 ALC1220_VB_DESKTOP(0x0db0, 0x543d), /* MSI TRX40 */ 3712 ALC1220_VB_DESKTOP(0x26ce, 0x0a01), /* Asrock TRX40 Creator */ 3713 #undef ALC1220_VB_DESKTOP 3714 3715 /* Two entries for Gigabyte TRX40 Aorus Master: 3716 * TRX40 Aorus Master has two USB-audio devices, one for the front headphone 3717 * with ESS SABRE9218 DAC chip, while another for the rest I/O (the rear 3718 * panel and the front mic) with Realtek ALC1220-VB. 3719 * Here we provide two distinct names for making UCM profiles easier. 3720 */ 3721 { 3722 USB_DEVICE(0x0414, 0xa000), 3723 QUIRK_DEVICE_PROFILE("Gigabyte", "Aorus Master Front Headphone", 3724 "Gigabyte-Aorus-Master-Front-Headphone") 3725 }, 3726 { 3727 USB_DEVICE(0x0414, 0xa001), 3728 QUIRK_DEVICE_PROFILE("Gigabyte", "Aorus Master Main Audio", 3729 "Gigabyte-Aorus-Master-Main-Audio") 3730 }, 3731 { 3732 /* 3733 * Pioneer DJ DJM-900NXS2 3734 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE 3735 */ 3736 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a), 3737 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3738 .ifnum = QUIRK_ANY_INTERFACE, 3739 .type = QUIRK_COMPOSITE, 3740 .data = (const struct snd_usb_audio_quirk[]) { 3741 { 3742 .ifnum = 0, 3743 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3744 .data = &(const struct audioformat) { 3745 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3746 .channels = 10, 3747 .iface = 0, 3748 .altsetting = 1, 3749 .altset_idx = 1, 3750 .endpoint = 0x01, 3751 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3752 USB_ENDPOINT_SYNC_ASYNC, 3753 .rates = SNDRV_PCM_RATE_44100| 3754 SNDRV_PCM_RATE_48000| 3755 SNDRV_PCM_RATE_96000, 3756 .rate_min = 44100, 3757 .rate_max = 96000, 3758 .nr_rates = 3, 3759 .rate_table = (unsigned int[]) { 3760 44100, 48000, 96000 3761 } 3762 } 3763 }, 3764 { 3765 .ifnum = 0, 3766 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3767 .data = &(const struct audioformat) { 3768 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3769 .channels = 12, 3770 .iface = 0, 3771 .altsetting = 1, 3772 .altset_idx = 1, 3773 .endpoint = 0x82, 3774 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3775 USB_ENDPOINT_SYNC_ASYNC| 3776 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3777 .rates = SNDRV_PCM_RATE_44100| 3778 SNDRV_PCM_RATE_48000| 3779 SNDRV_PCM_RATE_96000, 3780 .rate_min = 44100, 3781 .rate_max = 96000, 3782 .nr_rates = 3, 3783 .rate_table = (unsigned int[]) { 3784 44100, 48000, 96000 3785 } 3786 } 3787 }, 3788 { 3789 .ifnum = -1 3790 } 3791 } 3792 } 3793 }, 3794 3795 /* 3796 * MacroSilicon MS2109 based HDMI capture cards 3797 * 3798 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch. 3799 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if 3800 * they pretend to be 96kHz mono as a workaround for stereo being broken 3801 * by that... 3802 * 3803 * They also have an issue with initial stream alignment that causes the 3804 * channels to be swapped and out of phase, which is dealt with in quirks.c. 3805 */ 3806 { 3807 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 3808 USB_DEVICE_ID_MATCH_INT_CLASS | 3809 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 3810 .idVendor = 0x534d, 3811 .idProduct = 0x2109, 3812 .bInterfaceClass = USB_CLASS_AUDIO, 3813 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 3814 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3815 .vendor_name = "MacroSilicon", 3816 .product_name = "MS2109", 3817 .ifnum = QUIRK_ANY_INTERFACE, 3818 .type = QUIRK_COMPOSITE, 3819 .data = &(const struct snd_usb_audio_quirk[]) { 3820 { 3821 .ifnum = 2, 3822 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 3823 }, 3824 { 3825 .ifnum = 2, 3826 .type = QUIRK_AUDIO_STANDARD_MIXER, 3827 }, 3828 { 3829 .ifnum = 3, 3830 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3831 .data = &(const struct audioformat) { 3832 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3833 .channels = 2, 3834 .iface = 3, 3835 .altsetting = 1, 3836 .altset_idx = 1, 3837 .attributes = 0, 3838 .endpoint = 0x82, 3839 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3840 USB_ENDPOINT_SYNC_ASYNC, 3841 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3842 .rate_min = 48000, 3843 .rate_max = 48000, 3844 } 3845 }, 3846 { 3847 .ifnum = -1 3848 } 3849 } 3850 } 3851 }, 3852 3853 #undef USB_DEVICE_VENDOR_SPEC 3854