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 /* A standard entry matching with vid/pid and the audio class/subclass */ 29 #define USB_AUDIO_DEVICE(vend, prod) \ 30 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \ 31 USB_DEVICE_ID_MATCH_INT_CLASS | \ 32 USB_DEVICE_ID_MATCH_INT_SUBCLASS, \ 33 .idVendor = vend, \ 34 .idProduct = prod, \ 35 .bInterfaceClass = USB_CLASS_AUDIO, \ 36 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL 37 38 /* FTDI devices */ 39 { 40 USB_DEVICE(0x0403, 0xb8d8), 41 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 42 /* .vendor_name = "STARR LABS", */ 43 /* .product_name = "Starr Labs MIDI USB device", */ 44 .ifnum = 0, 45 .type = QUIRK_MIDI_FTDI 46 } 47 }, 48 49 { 50 /* Creative BT-D1 */ 51 USB_DEVICE(0x041e, 0x0005), 52 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 53 .ifnum = 1, 54 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 55 .data = &(const struct audioformat) { 56 .formats = SNDRV_PCM_FMTBIT_S16_LE, 57 .channels = 2, 58 .iface = 1, 59 .altsetting = 1, 60 .altset_idx = 1, 61 .endpoint = 0x03, 62 .ep_attr = USB_ENDPOINT_XFER_ISOC, 63 .attributes = 0, 64 .rates = SNDRV_PCM_RATE_CONTINUOUS, 65 .rate_min = 48000, 66 .rate_max = 48000, 67 } 68 } 69 }, 70 71 /* E-Mu 0202 USB */ 72 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f02) }, 73 /* E-Mu 0404 USB */ 74 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f04) }, 75 /* E-Mu Tracker Pre */ 76 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f0a) }, 77 /* E-Mu 0204 USB */ 78 { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f19) }, 79 /* Ktmicro Usb_audio device */ 80 { USB_DEVICE_VENDOR_SPEC(0x31b2, 0x0011) }, 81 82 /* 83 * Creative Technology, Ltd Live! Cam Sync HD [VF0770] 84 * The device advertises 8 formats, but only a rate of 48kHz is honored by the 85 * hardware and 24 bits give chopped audio, so only report the one working 86 * combination. 87 */ 88 { 89 USB_AUDIO_DEVICE(0x041e, 0x4095), 90 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 91 .ifnum = QUIRK_ANY_INTERFACE, 92 .type = QUIRK_COMPOSITE, 93 .data = &(const struct snd_usb_audio_quirk[]) { 94 { 95 .ifnum = 2, 96 .type = QUIRK_AUDIO_STANDARD_MIXER, 97 }, 98 { 99 .ifnum = 3, 100 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 101 .data = &(const struct audioformat) { 102 .formats = SNDRV_PCM_FMTBIT_S16_LE, 103 .channels = 2, 104 .fmt_bits = 16, 105 .iface = 3, 106 .altsetting = 4, 107 .altset_idx = 4, 108 .endpoint = 0x82, 109 .ep_attr = 0x05, 110 .rates = SNDRV_PCM_RATE_48000, 111 .rate_min = 48000, 112 .rate_max = 48000, 113 .nr_rates = 1, 114 .rate_table = (unsigned int[]) { 48000 }, 115 }, 116 }, 117 { 118 .ifnum = -1 119 }, 120 }, 121 }, 122 }, 123 124 /* 125 * HP Wireless Audio 126 * When not ignored, causes instability issues for some users, forcing them to 127 * skip the entire module. 128 */ 129 { 130 USB_DEVICE(0x0424, 0xb832), 131 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 132 .vendor_name = "Standard Microsystems Corp.", 133 .product_name = "HP Wireless Audio", 134 .ifnum = QUIRK_ANY_INTERFACE, 135 .type = QUIRK_COMPOSITE, 136 .data = (const struct snd_usb_audio_quirk[]) { 137 /* Mixer */ 138 { 139 .ifnum = 0, 140 .type = QUIRK_IGNORE_INTERFACE, 141 }, 142 /* Playback */ 143 { 144 .ifnum = 1, 145 .type = QUIRK_IGNORE_INTERFACE, 146 }, 147 /* Capture */ 148 { 149 .ifnum = 2, 150 .type = QUIRK_IGNORE_INTERFACE, 151 }, 152 /* HID Device, .ifnum = 3 */ 153 { 154 .ifnum = -1, 155 } 156 } 157 } 158 }, 159 160 /* 161 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface 162 * class matches do not take effect without an explicit ID match. 163 */ 164 { USB_AUDIO_DEVICE(0x046d, 0x0850) }, 165 { USB_AUDIO_DEVICE(0x046d, 0x08ae) }, 166 { USB_AUDIO_DEVICE(0x046d, 0x08c6) }, 167 { USB_AUDIO_DEVICE(0x046d, 0x08f0) }, 168 { USB_AUDIO_DEVICE(0x046d, 0x08f5) }, 169 { USB_AUDIO_DEVICE(0x046d, 0x08f6) }, 170 { USB_AUDIO_DEVICE(0x046d, 0x0990) }, 171 172 /* 173 * Yamaha devices 174 */ 175 176 #define YAMAHA_DEVICE(id, name) { \ 177 USB_DEVICE(0x0499, id), \ 178 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ 179 .vendor_name = "Yamaha", \ 180 .product_name = name, \ 181 .ifnum = QUIRK_ANY_INTERFACE, \ 182 .type = QUIRK_MIDI_YAMAHA \ 183 } \ 184 } 185 #define YAMAHA_INTERFACE(id, intf, name) { \ 186 USB_DEVICE_VENDOR_SPEC(0x0499, id), \ 187 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ 188 .vendor_name = "Yamaha", \ 189 .product_name = name, \ 190 .ifnum = intf, \ 191 .type = QUIRK_MIDI_YAMAHA \ 192 } \ 193 } 194 YAMAHA_DEVICE(0x1000, "UX256"), 195 YAMAHA_DEVICE(0x1001, "MU1000"), 196 YAMAHA_DEVICE(0x1002, "MU2000"), 197 YAMAHA_DEVICE(0x1003, "MU500"), 198 YAMAHA_INTERFACE(0x1004, 3, "UW500"), 199 YAMAHA_DEVICE(0x1005, "MOTIF6"), 200 YAMAHA_DEVICE(0x1006, "MOTIF7"), 201 YAMAHA_DEVICE(0x1007, "MOTIF8"), 202 YAMAHA_DEVICE(0x1008, "UX96"), 203 YAMAHA_DEVICE(0x1009, "UX16"), 204 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"), 205 YAMAHA_DEVICE(0x100c, "UC-MX"), 206 YAMAHA_DEVICE(0x100d, "UC-KX"), 207 YAMAHA_DEVICE(0x100e, "S08"), 208 YAMAHA_DEVICE(0x100f, "CLP-150"), 209 YAMAHA_DEVICE(0x1010, "CLP-170"), 210 YAMAHA_DEVICE(0x1011, "P-250"), 211 YAMAHA_DEVICE(0x1012, "TYROS"), 212 YAMAHA_DEVICE(0x1013, "PF-500"), 213 YAMAHA_DEVICE(0x1014, "S90"), 214 YAMAHA_DEVICE(0x1015, "MOTIF-R"), 215 YAMAHA_DEVICE(0x1016, "MDP-5"), 216 YAMAHA_DEVICE(0x1017, "CVP-204"), 217 YAMAHA_DEVICE(0x1018, "CVP-206"), 218 YAMAHA_DEVICE(0x1019, "CVP-208"), 219 YAMAHA_DEVICE(0x101a, "CVP-210"), 220 YAMAHA_DEVICE(0x101b, "PSR-1100"), 221 YAMAHA_DEVICE(0x101c, "PSR-2100"), 222 YAMAHA_DEVICE(0x101d, "CLP-175"), 223 YAMAHA_DEVICE(0x101e, "PSR-K1"), 224 YAMAHA_DEVICE(0x101f, "EZ-J24"), 225 YAMAHA_DEVICE(0x1020, "EZ-250i"), 226 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"), 227 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"), 228 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"), 229 YAMAHA_DEVICE(0x1024, "CVP-301"), 230 YAMAHA_DEVICE(0x1025, "CVP-303"), 231 YAMAHA_DEVICE(0x1026, "CVP-305"), 232 YAMAHA_DEVICE(0x1027, "CVP-307"), 233 YAMAHA_DEVICE(0x1028, "CVP-309"), 234 YAMAHA_DEVICE(0x1029, "CVP-309GP"), 235 YAMAHA_DEVICE(0x102a, "PSR-1500"), 236 YAMAHA_DEVICE(0x102b, "PSR-3000"), 237 YAMAHA_DEVICE(0x102e, "ELS-01/01C"), 238 YAMAHA_DEVICE(0x1030, "PSR-295/293"), 239 YAMAHA_DEVICE(0x1031, "DGX-205/203"), 240 YAMAHA_DEVICE(0x1032, "DGX-305"), 241 YAMAHA_DEVICE(0x1033, "DGX-505"), 242 YAMAHA_DEVICE(0x1034, NULL), 243 YAMAHA_DEVICE(0x1035, NULL), 244 YAMAHA_DEVICE(0x1036, NULL), 245 YAMAHA_DEVICE(0x1037, NULL), 246 YAMAHA_DEVICE(0x1038, NULL), 247 YAMAHA_DEVICE(0x1039, NULL), 248 YAMAHA_DEVICE(0x103a, NULL), 249 YAMAHA_DEVICE(0x103b, NULL), 250 YAMAHA_DEVICE(0x103c, NULL), 251 YAMAHA_DEVICE(0x103d, NULL), 252 YAMAHA_DEVICE(0x103e, NULL), 253 YAMAHA_DEVICE(0x103f, NULL), 254 YAMAHA_DEVICE(0x1040, NULL), 255 YAMAHA_DEVICE(0x1041, NULL), 256 YAMAHA_DEVICE(0x1042, NULL), 257 YAMAHA_DEVICE(0x1043, NULL), 258 YAMAHA_DEVICE(0x1044, NULL), 259 YAMAHA_DEVICE(0x1045, NULL), 260 YAMAHA_INTERFACE(0x104e, 0, NULL), 261 YAMAHA_DEVICE(0x104f, NULL), 262 YAMAHA_DEVICE(0x1050, NULL), 263 YAMAHA_DEVICE(0x1051, NULL), 264 YAMAHA_DEVICE(0x1052, NULL), 265 YAMAHA_INTERFACE(0x1053, 0, NULL), 266 YAMAHA_INTERFACE(0x1054, 0, NULL), 267 YAMAHA_DEVICE(0x1055, NULL), 268 YAMAHA_DEVICE(0x1056, NULL), 269 YAMAHA_DEVICE(0x1057, NULL), 270 YAMAHA_DEVICE(0x1058, NULL), 271 YAMAHA_DEVICE(0x1059, NULL), 272 YAMAHA_DEVICE(0x105a, NULL), 273 YAMAHA_DEVICE(0x105b, NULL), 274 YAMAHA_DEVICE(0x105c, NULL), 275 YAMAHA_DEVICE(0x105d, NULL), 276 YAMAHA_DEVICE(0x1718, "P-125"), 277 { 278 USB_DEVICE(0x0499, 0x1503), 279 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 280 /* .vendor_name = "Yamaha", */ 281 /* .product_name = "MOX6/MOX8", */ 282 .ifnum = QUIRK_ANY_INTERFACE, 283 .type = QUIRK_COMPOSITE, 284 .data = (const struct snd_usb_audio_quirk[]) { 285 { 286 .ifnum = 1, 287 .type = QUIRK_AUDIO_STANDARD_INTERFACE 288 }, 289 { 290 .ifnum = 2, 291 .type = QUIRK_AUDIO_STANDARD_INTERFACE 292 }, 293 { 294 .ifnum = 3, 295 .type = QUIRK_MIDI_YAMAHA 296 }, 297 { 298 .ifnum = -1 299 } 300 } 301 } 302 }, 303 { 304 USB_DEVICE(0x0499, 0x1507), 305 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 306 /* .vendor_name = "Yamaha", */ 307 /* .product_name = "THR10", */ 308 .ifnum = QUIRK_ANY_INTERFACE, 309 .type = QUIRK_COMPOSITE, 310 .data = (const struct snd_usb_audio_quirk[]) { 311 { 312 .ifnum = 1, 313 .type = QUIRK_AUDIO_STANDARD_INTERFACE 314 }, 315 { 316 .ifnum = 2, 317 .type = QUIRK_AUDIO_STANDARD_INTERFACE 318 }, 319 { 320 .ifnum = 3, 321 .type = QUIRK_MIDI_YAMAHA 322 }, 323 { 324 .ifnum = -1 325 } 326 } 327 } 328 }, 329 { 330 USB_DEVICE(0x0499, 0x1509), 331 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 332 /* .vendor_name = "Yamaha", */ 333 /* .product_name = "Steinberg UR22", */ 334 .ifnum = QUIRK_ANY_INTERFACE, 335 .type = QUIRK_COMPOSITE, 336 .data = (const struct snd_usb_audio_quirk[]) { 337 { 338 .ifnum = 1, 339 .type = QUIRK_AUDIO_STANDARD_INTERFACE 340 }, 341 { 342 .ifnum = 2, 343 .type = QUIRK_AUDIO_STANDARD_INTERFACE 344 }, 345 { 346 .ifnum = 3, 347 .type = QUIRK_MIDI_YAMAHA 348 }, 349 { 350 .ifnum = 4, 351 .type = QUIRK_IGNORE_INTERFACE 352 }, 353 { 354 .ifnum = -1 355 } 356 } 357 } 358 }, 359 { 360 USB_DEVICE(0x0499, 0x150a), 361 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 362 /* .vendor_name = "Yamaha", */ 363 /* .product_name = "THR5A", */ 364 .ifnum = QUIRK_ANY_INTERFACE, 365 .type = QUIRK_COMPOSITE, 366 .data = (const struct snd_usb_audio_quirk[]) { 367 { 368 .ifnum = 1, 369 .type = QUIRK_AUDIO_STANDARD_INTERFACE 370 }, 371 { 372 .ifnum = 2, 373 .type = QUIRK_AUDIO_STANDARD_INTERFACE 374 }, 375 { 376 .ifnum = 3, 377 .type = QUIRK_MIDI_YAMAHA 378 }, 379 { 380 .ifnum = -1 381 } 382 } 383 } 384 }, 385 { 386 USB_DEVICE(0x0499, 0x150c), 387 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 388 /* .vendor_name = "Yamaha", */ 389 /* .product_name = "THR10C", */ 390 .ifnum = QUIRK_ANY_INTERFACE, 391 .type = QUIRK_COMPOSITE, 392 .data = (const struct snd_usb_audio_quirk[]) { 393 { 394 .ifnum = 1, 395 .type = QUIRK_AUDIO_STANDARD_INTERFACE 396 }, 397 { 398 .ifnum = 2, 399 .type = QUIRK_AUDIO_STANDARD_INTERFACE 400 }, 401 { 402 .ifnum = 3, 403 .type = QUIRK_MIDI_YAMAHA 404 }, 405 { 406 .ifnum = -1 407 } 408 } 409 } 410 }, 411 YAMAHA_DEVICE(0x2000, "DGP-7"), 412 YAMAHA_DEVICE(0x2001, "DGP-5"), 413 YAMAHA_DEVICE(0x2002, NULL), 414 YAMAHA_DEVICE(0x2003, NULL), 415 YAMAHA_DEVICE(0x5000, "CS1D"), 416 YAMAHA_DEVICE(0x5001, "DSP1D"), 417 YAMAHA_DEVICE(0x5002, "DME32"), 418 YAMAHA_DEVICE(0x5003, "DM2000"), 419 YAMAHA_DEVICE(0x5004, "02R96"), 420 YAMAHA_DEVICE(0x5005, "ACU16-C"), 421 YAMAHA_DEVICE(0x5006, "NHB32-C"), 422 YAMAHA_DEVICE(0x5007, "DM1000"), 423 YAMAHA_DEVICE(0x5008, "01V96"), 424 YAMAHA_DEVICE(0x5009, "SPX2000"), 425 YAMAHA_DEVICE(0x500a, "PM5D"), 426 YAMAHA_DEVICE(0x500b, "DME64N"), 427 YAMAHA_DEVICE(0x500c, "DME24N"), 428 YAMAHA_DEVICE(0x500d, NULL), 429 YAMAHA_DEVICE(0x500e, NULL), 430 YAMAHA_DEVICE(0x500f, NULL), 431 YAMAHA_DEVICE(0x7000, "DTX"), 432 YAMAHA_DEVICE(0x7010, "UB99"), 433 #undef YAMAHA_DEVICE 434 #undef YAMAHA_INTERFACE 435 /* this catches most recent vendor-specific Yamaha devices */ 436 { 437 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 438 USB_DEVICE_ID_MATCH_INT_CLASS, 439 .idVendor = 0x0499, 440 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 441 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 442 .ifnum = QUIRK_ANY_INTERFACE, 443 .type = QUIRK_AUTODETECT 444 } 445 }, 446 447 /* 448 * Roland/RolandED/Edirol/BOSS devices 449 */ 450 { 451 USB_DEVICE(0x0582, 0x0000), 452 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 453 .vendor_name = "Roland", 454 .product_name = "UA-100", 455 .ifnum = QUIRK_ANY_INTERFACE, 456 .type = QUIRK_COMPOSITE, 457 .data = (const struct snd_usb_audio_quirk[]) { 458 { 459 .ifnum = 0, 460 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 461 .data = & (const struct audioformat) { 462 .formats = SNDRV_PCM_FMTBIT_S16_LE, 463 .channels = 4, 464 .iface = 0, 465 .altsetting = 1, 466 .altset_idx = 1, 467 .attributes = 0, 468 .endpoint = 0x01, 469 .ep_attr = 0x09, 470 .rates = SNDRV_PCM_RATE_CONTINUOUS, 471 .rate_min = 44100, 472 .rate_max = 44100, 473 } 474 }, 475 { 476 .ifnum = 1, 477 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 478 .data = & (const struct audioformat) { 479 .formats = SNDRV_PCM_FMTBIT_S16_LE, 480 .channels = 2, 481 .iface = 1, 482 .altsetting = 1, 483 .altset_idx = 1, 484 .attributes = UAC_EP_CS_ATTR_FILL_MAX, 485 .endpoint = 0x81, 486 .ep_attr = 0x05, 487 .rates = SNDRV_PCM_RATE_CONTINUOUS, 488 .rate_min = 44100, 489 .rate_max = 44100, 490 } 491 }, 492 { 493 .ifnum = 2, 494 .type = QUIRK_MIDI_FIXED_ENDPOINT, 495 .data = & (const struct snd_usb_midi_endpoint_info) { 496 .out_cables = 0x0007, 497 .in_cables = 0x0007 498 } 499 }, 500 { 501 .ifnum = -1 502 } 503 } 504 } 505 }, 506 { 507 USB_DEVICE(0x0582, 0x0002), 508 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 509 .vendor_name = "EDIROL", 510 .product_name = "UM-4", 511 .ifnum = QUIRK_ANY_INTERFACE, 512 .type = QUIRK_COMPOSITE, 513 .data = (const struct snd_usb_audio_quirk[]) { 514 { 515 .ifnum = 0, 516 .type = QUIRK_IGNORE_INTERFACE 517 }, 518 { 519 .ifnum = 1, 520 .type = QUIRK_IGNORE_INTERFACE 521 }, 522 { 523 .ifnum = 2, 524 .type = QUIRK_MIDI_FIXED_ENDPOINT, 525 .data = & (const struct snd_usb_midi_endpoint_info) { 526 .out_cables = 0x000f, 527 .in_cables = 0x000f 528 } 529 }, 530 { 531 .ifnum = -1 532 } 533 } 534 } 535 }, 536 { 537 USB_DEVICE(0x0582, 0x0003), 538 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 539 .vendor_name = "Roland", 540 .product_name = "SC-8850", 541 .ifnum = QUIRK_ANY_INTERFACE, 542 .type = QUIRK_COMPOSITE, 543 .data = (const struct snd_usb_audio_quirk[]) { 544 { 545 .ifnum = 0, 546 .type = QUIRK_IGNORE_INTERFACE 547 }, 548 { 549 .ifnum = 1, 550 .type = QUIRK_IGNORE_INTERFACE 551 }, 552 { 553 .ifnum = 2, 554 .type = QUIRK_MIDI_FIXED_ENDPOINT, 555 .data = & (const struct snd_usb_midi_endpoint_info) { 556 .out_cables = 0x003f, 557 .in_cables = 0x003f 558 } 559 }, 560 { 561 .ifnum = -1 562 } 563 } 564 } 565 }, 566 { 567 USB_DEVICE(0x0582, 0x0004), 568 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 569 .vendor_name = "Roland", 570 .product_name = "U-8", 571 .ifnum = QUIRK_ANY_INTERFACE, 572 .type = QUIRK_COMPOSITE, 573 .data = (const struct snd_usb_audio_quirk[]) { 574 { 575 .ifnum = 0, 576 .type = QUIRK_IGNORE_INTERFACE 577 }, 578 { 579 .ifnum = 1, 580 .type = QUIRK_IGNORE_INTERFACE 581 }, 582 { 583 .ifnum = 2, 584 .type = QUIRK_MIDI_FIXED_ENDPOINT, 585 .data = & (const struct snd_usb_midi_endpoint_info) { 586 .out_cables = 0x0005, 587 .in_cables = 0x0005 588 } 589 }, 590 { 591 .ifnum = -1 592 } 593 } 594 } 595 }, 596 { 597 /* Has ID 0x0099 when not in "Advanced Driver" mode. 598 * The UM-2EX has only one input, but we cannot detect this. */ 599 USB_DEVICE(0x0582, 0x0005), 600 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 601 .vendor_name = "EDIROL", 602 .product_name = "UM-2", 603 .ifnum = QUIRK_ANY_INTERFACE, 604 .type = QUIRK_COMPOSITE, 605 .data = (const struct snd_usb_audio_quirk[]) { 606 { 607 .ifnum = 0, 608 .type = QUIRK_IGNORE_INTERFACE 609 }, 610 { 611 .ifnum = 1, 612 .type = QUIRK_IGNORE_INTERFACE 613 }, 614 { 615 .ifnum = 2, 616 .type = QUIRK_MIDI_FIXED_ENDPOINT, 617 .data = & (const struct snd_usb_midi_endpoint_info) { 618 .out_cables = 0x0003, 619 .in_cables = 0x0003 620 } 621 }, 622 { 623 .ifnum = -1 624 } 625 } 626 } 627 }, 628 { 629 USB_DEVICE(0x0582, 0x0007), 630 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 631 .vendor_name = "Roland", 632 .product_name = "SC-8820", 633 .ifnum = QUIRK_ANY_INTERFACE, 634 .type = QUIRK_COMPOSITE, 635 .data = (const struct snd_usb_audio_quirk[]) { 636 { 637 .ifnum = 0, 638 .type = QUIRK_IGNORE_INTERFACE 639 }, 640 { 641 .ifnum = 1, 642 .type = QUIRK_IGNORE_INTERFACE 643 }, 644 { 645 .ifnum = 2, 646 .type = QUIRK_MIDI_FIXED_ENDPOINT, 647 .data = & (const struct snd_usb_midi_endpoint_info) { 648 .out_cables = 0x0013, 649 .in_cables = 0x0013 650 } 651 }, 652 { 653 .ifnum = -1 654 } 655 } 656 } 657 }, 658 { 659 USB_DEVICE(0x0582, 0x0008), 660 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 661 .vendor_name = "Roland", 662 .product_name = "PC-300", 663 .ifnum = QUIRK_ANY_INTERFACE, 664 .type = QUIRK_COMPOSITE, 665 .data = (const struct snd_usb_audio_quirk[]) { 666 { 667 .ifnum = 0, 668 .type = QUIRK_IGNORE_INTERFACE 669 }, 670 { 671 .ifnum = 1, 672 .type = QUIRK_IGNORE_INTERFACE 673 }, 674 { 675 .ifnum = 2, 676 .type = QUIRK_MIDI_FIXED_ENDPOINT, 677 .data = & (const struct snd_usb_midi_endpoint_info) { 678 .out_cables = 0x0001, 679 .in_cables = 0x0001 680 } 681 }, 682 { 683 .ifnum = -1 684 } 685 } 686 } 687 }, 688 { 689 /* has ID 0x009d when not in "Advanced Driver" mode */ 690 USB_DEVICE(0x0582, 0x0009), 691 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 692 .vendor_name = "EDIROL", 693 .product_name = "UM-1", 694 .ifnum = QUIRK_ANY_INTERFACE, 695 .type = QUIRK_COMPOSITE, 696 .data = (const struct snd_usb_audio_quirk[]) { 697 { 698 .ifnum = 0, 699 .type = QUIRK_IGNORE_INTERFACE 700 }, 701 { 702 .ifnum = 1, 703 .type = QUIRK_IGNORE_INTERFACE 704 }, 705 { 706 .ifnum = 2, 707 .type = QUIRK_MIDI_FIXED_ENDPOINT, 708 .data = & (const struct snd_usb_midi_endpoint_info) { 709 .out_cables = 0x0001, 710 .in_cables = 0x0001 711 } 712 }, 713 { 714 .ifnum = -1 715 } 716 } 717 } 718 }, 719 { 720 USB_DEVICE(0x0582, 0x000b), 721 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 722 .vendor_name = "Roland", 723 .product_name = "SK-500", 724 .ifnum = QUIRK_ANY_INTERFACE, 725 .type = QUIRK_COMPOSITE, 726 .data = (const struct snd_usb_audio_quirk[]) { 727 { 728 .ifnum = 0, 729 .type = QUIRK_IGNORE_INTERFACE 730 }, 731 { 732 .ifnum = 1, 733 .type = QUIRK_IGNORE_INTERFACE 734 }, 735 { 736 .ifnum = 2, 737 .type = QUIRK_MIDI_FIXED_ENDPOINT, 738 .data = & (const struct snd_usb_midi_endpoint_info) { 739 .out_cables = 0x0013, 740 .in_cables = 0x0013 741 } 742 }, 743 { 744 .ifnum = -1 745 } 746 } 747 } 748 }, 749 { 750 /* thanks to Emiliano Grilli <emillo@libero.it> 751 * for helping researching this data */ 752 USB_DEVICE(0x0582, 0x000c), 753 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 754 .vendor_name = "Roland", 755 .product_name = "SC-D70", 756 .ifnum = QUIRK_ANY_INTERFACE, 757 .type = QUIRK_COMPOSITE, 758 .data = (const struct snd_usb_audio_quirk[]) { 759 { 760 .ifnum = 0, 761 .type = QUIRK_AUDIO_STANDARD_INTERFACE 762 }, 763 { 764 .ifnum = 1, 765 .type = QUIRK_AUDIO_STANDARD_INTERFACE 766 }, 767 { 768 .ifnum = 2, 769 .type = QUIRK_MIDI_FIXED_ENDPOINT, 770 .data = & (const struct snd_usb_midi_endpoint_info) { 771 .out_cables = 0x0007, 772 .in_cables = 0x0007 773 } 774 }, 775 { 776 .ifnum = -1 777 } 778 } 779 } 780 }, 781 { /* 782 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5. 783 * If the advanced mode switch at the back of the unit is off, the 784 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks), 785 * but offers only 16-bit PCM. 786 * In advanced mode, the UA-5 will output S24_3LE samples (two 787 * channels) at the rate indicated on the front switch, including 788 * the 96kHz sample rate. 789 */ 790 USB_DEVICE(0x0582, 0x0010), 791 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 792 .vendor_name = "EDIROL", 793 .product_name = "UA-5", 794 .ifnum = QUIRK_ANY_INTERFACE, 795 .type = QUIRK_COMPOSITE, 796 .data = (const struct snd_usb_audio_quirk[]) { 797 { 798 .ifnum = 1, 799 .type = QUIRK_AUDIO_STANDARD_INTERFACE 800 }, 801 { 802 .ifnum = 2, 803 .type = QUIRK_AUDIO_STANDARD_INTERFACE 804 }, 805 { 806 .ifnum = -1 807 } 808 } 809 } 810 }, 811 { 812 /* has ID 0x0013 when not in "Advanced Driver" mode */ 813 USB_DEVICE(0x0582, 0x0012), 814 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 815 .vendor_name = "Roland", 816 .product_name = "XV-5050", 817 .ifnum = 0, 818 .type = QUIRK_MIDI_FIXED_ENDPOINT, 819 .data = & (const struct snd_usb_midi_endpoint_info) { 820 .out_cables = 0x0001, 821 .in_cables = 0x0001 822 } 823 } 824 }, 825 { 826 /* has ID 0x0015 when not in "Advanced Driver" mode */ 827 USB_DEVICE(0x0582, 0x0014), 828 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 829 .vendor_name = "EDIROL", 830 .product_name = "UM-880", 831 .ifnum = 0, 832 .type = QUIRK_MIDI_FIXED_ENDPOINT, 833 .data = & (const struct snd_usb_midi_endpoint_info) { 834 .out_cables = 0x01ff, 835 .in_cables = 0x01ff 836 } 837 } 838 }, 839 { 840 /* has ID 0x0017 when not in "Advanced Driver" mode */ 841 USB_DEVICE(0x0582, 0x0016), 842 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 843 .vendor_name = "EDIROL", 844 .product_name = "SD-90", 845 .ifnum = QUIRK_ANY_INTERFACE, 846 .type = QUIRK_COMPOSITE, 847 .data = (const struct snd_usb_audio_quirk[]) { 848 { 849 .ifnum = 0, 850 .type = QUIRK_AUDIO_STANDARD_INTERFACE 851 }, 852 { 853 .ifnum = 1, 854 .type = QUIRK_AUDIO_STANDARD_INTERFACE 855 }, 856 { 857 .ifnum = 2, 858 .type = QUIRK_MIDI_FIXED_ENDPOINT, 859 .data = & (const struct snd_usb_midi_endpoint_info) { 860 .out_cables = 0x000f, 861 .in_cables = 0x000f 862 } 863 }, 864 { 865 .ifnum = -1 866 } 867 } 868 } 869 }, 870 { 871 /* has ID 0x001c when not in "Advanced Driver" mode */ 872 USB_DEVICE(0x0582, 0x001b), 873 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 874 .vendor_name = "Roland", 875 .product_name = "MMP-2", 876 .ifnum = QUIRK_ANY_INTERFACE, 877 .type = QUIRK_COMPOSITE, 878 .data = (const struct snd_usb_audio_quirk[]) { 879 { 880 .ifnum = 0, 881 .type = QUIRK_IGNORE_INTERFACE 882 }, 883 { 884 .ifnum = 1, 885 .type = QUIRK_IGNORE_INTERFACE 886 }, 887 { 888 .ifnum = 2, 889 .type = QUIRK_MIDI_FIXED_ENDPOINT, 890 .data = & (const struct snd_usb_midi_endpoint_info) { 891 .out_cables = 0x0001, 892 .in_cables = 0x0001 893 } 894 }, 895 { 896 .ifnum = -1 897 } 898 } 899 } 900 }, 901 { 902 /* has ID 0x001e when not in "Advanced Driver" mode */ 903 USB_DEVICE(0x0582, 0x001d), 904 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 905 .vendor_name = "Roland", 906 .product_name = "V-SYNTH", 907 .ifnum = 0, 908 .type = QUIRK_MIDI_FIXED_ENDPOINT, 909 .data = & (const struct snd_usb_midi_endpoint_info) { 910 .out_cables = 0x0001, 911 .in_cables = 0x0001 912 } 913 } 914 }, 915 { 916 /* has ID 0x0024 when not in "Advanced Driver" mode */ 917 USB_DEVICE(0x0582, 0x0023), 918 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 919 .vendor_name = "EDIROL", 920 .product_name = "UM-550", 921 .ifnum = 0, 922 .type = QUIRK_MIDI_FIXED_ENDPOINT, 923 .data = & (const struct snd_usb_midi_endpoint_info) { 924 .out_cables = 0x003f, 925 .in_cables = 0x003f 926 } 927 } 928 }, 929 { 930 /* 931 * This quirk is for the "Advanced Driver" mode. If off, the UA-20 932 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM 933 * and no MIDI. 934 */ 935 USB_DEVICE(0x0582, 0x0025), 936 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 937 .vendor_name = "EDIROL", 938 .product_name = "UA-20", 939 .ifnum = QUIRK_ANY_INTERFACE, 940 .type = QUIRK_COMPOSITE, 941 .data = (const struct snd_usb_audio_quirk[]) { 942 { 943 .ifnum = 0, 944 .type = QUIRK_IGNORE_INTERFACE 945 }, 946 { 947 .ifnum = 1, 948 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 949 .data = & (const struct audioformat) { 950 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 951 .channels = 2, 952 .iface = 1, 953 .altsetting = 1, 954 .altset_idx = 1, 955 .attributes = 0, 956 .endpoint = 0x01, 957 .ep_attr = 0x01, 958 .rates = SNDRV_PCM_RATE_CONTINUOUS, 959 .rate_min = 44100, 960 .rate_max = 44100, 961 } 962 }, 963 { 964 .ifnum = 2, 965 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 966 .data = & (const struct audioformat) { 967 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 968 .channels = 2, 969 .iface = 2, 970 .altsetting = 1, 971 .altset_idx = 1, 972 .attributes = 0, 973 .endpoint = 0x82, 974 .ep_attr = 0x01, 975 .rates = SNDRV_PCM_RATE_CONTINUOUS, 976 .rate_min = 44100, 977 .rate_max = 44100, 978 } 979 }, 980 { 981 .ifnum = 3, 982 .type = QUIRK_MIDI_FIXED_ENDPOINT, 983 .data = & (const struct snd_usb_midi_endpoint_info) { 984 .out_cables = 0x0001, 985 .in_cables = 0x0001 986 } 987 }, 988 { 989 .ifnum = -1 990 } 991 } 992 } 993 }, 994 { 995 /* has ID 0x0028 when not in "Advanced Driver" mode */ 996 USB_DEVICE(0x0582, 0x0027), 997 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 998 .vendor_name = "EDIROL", 999 .product_name = "SD-20", 1000 .ifnum = 0, 1001 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1002 .data = & (const struct snd_usb_midi_endpoint_info) { 1003 .out_cables = 0x0003, 1004 .in_cables = 0x0007 1005 } 1006 } 1007 }, 1008 { 1009 /* has ID 0x002a when not in "Advanced Driver" mode */ 1010 USB_DEVICE(0x0582, 0x0029), 1011 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1012 .vendor_name = "EDIROL", 1013 .product_name = "SD-80", 1014 .ifnum = 0, 1015 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1016 .data = & (const struct snd_usb_midi_endpoint_info) { 1017 .out_cables = 0x000f, 1018 .in_cables = 0x000f 1019 } 1020 } 1021 }, 1022 { /* 1023 * This quirk is for the "Advanced" modes of the Edirol UA-700. 1024 * If the sample format switch is not in an advanced setting, the 1025 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks), 1026 * but offers only 16-bit PCM and no MIDI. 1027 */ 1028 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b), 1029 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1030 .vendor_name = "EDIROL", 1031 .product_name = "UA-700", 1032 .ifnum = QUIRK_ANY_INTERFACE, 1033 .type = QUIRK_COMPOSITE, 1034 .data = (const struct snd_usb_audio_quirk[]) { 1035 { 1036 .ifnum = 1, 1037 .type = QUIRK_AUDIO_EDIROL_UAXX 1038 }, 1039 { 1040 .ifnum = 2, 1041 .type = QUIRK_AUDIO_EDIROL_UAXX 1042 }, 1043 { 1044 .ifnum = 3, 1045 .type = QUIRK_AUDIO_EDIROL_UAXX 1046 }, 1047 { 1048 .ifnum = -1 1049 } 1050 } 1051 } 1052 }, 1053 { 1054 /* has ID 0x002e when not in "Advanced Driver" mode */ 1055 USB_DEVICE(0x0582, 0x002d), 1056 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1057 .vendor_name = "Roland", 1058 .product_name = "XV-2020", 1059 .ifnum = 0, 1060 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1061 .data = & (const struct snd_usb_midi_endpoint_info) { 1062 .out_cables = 0x0001, 1063 .in_cables = 0x0001 1064 } 1065 } 1066 }, 1067 { 1068 /* has ID 0x0030 when not in "Advanced Driver" mode */ 1069 USB_DEVICE(0x0582, 0x002f), 1070 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1071 .vendor_name = "Roland", 1072 .product_name = "VariOS", 1073 .ifnum = 0, 1074 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1075 .data = & (const struct snd_usb_midi_endpoint_info) { 1076 .out_cables = 0x0007, 1077 .in_cables = 0x0007 1078 } 1079 } 1080 }, 1081 { 1082 /* has ID 0x0034 when not in "Advanced Driver" mode */ 1083 USB_DEVICE(0x0582, 0x0033), 1084 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1085 .vendor_name = "EDIROL", 1086 .product_name = "PCR", 1087 .ifnum = 0, 1088 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1089 .data = & (const struct snd_usb_midi_endpoint_info) { 1090 .out_cables = 0x0003, 1091 .in_cables = 0x0007 1092 } 1093 } 1094 }, 1095 { 1096 /* 1097 * Has ID 0x0038 when not in "Advanced Driver" mode; 1098 * later revisions use IDs 0x0054 and 0x00a2. 1099 */ 1100 USB_DEVICE(0x0582, 0x0037), 1101 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1102 .vendor_name = "Roland", 1103 .product_name = "Digital Piano", 1104 .ifnum = 0, 1105 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1106 .data = & (const struct snd_usb_midi_endpoint_info) { 1107 .out_cables = 0x0001, 1108 .in_cables = 0x0001 1109 } 1110 } 1111 }, 1112 { 1113 /* 1114 * This quirk is for the "Advanced Driver" mode. If off, the GS-10 1115 * has ID 0x003c and is standard compliant, but has only 16-bit PCM 1116 * and no MIDI. 1117 */ 1118 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b), 1119 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1120 .vendor_name = "BOSS", 1121 .product_name = "GS-10", 1122 .ifnum = QUIRK_ANY_INTERFACE, 1123 .type = QUIRK_COMPOSITE, 1124 .data = & (const struct snd_usb_audio_quirk[]) { 1125 { 1126 .ifnum = 1, 1127 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1128 }, 1129 { 1130 .ifnum = 2, 1131 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1132 }, 1133 { 1134 .ifnum = 3, 1135 .type = QUIRK_MIDI_STANDARD_INTERFACE 1136 }, 1137 { 1138 .ifnum = -1 1139 } 1140 } 1141 } 1142 }, 1143 { 1144 /* has ID 0x0041 when not in "Advanced Driver" mode */ 1145 USB_DEVICE(0x0582, 0x0040), 1146 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1147 .vendor_name = "Roland", 1148 .product_name = "GI-20", 1149 .ifnum = 0, 1150 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1151 .data = & (const struct snd_usb_midi_endpoint_info) { 1152 .out_cables = 0x0001, 1153 .in_cables = 0x0001 1154 } 1155 } 1156 }, 1157 { 1158 /* has ID 0x0043 when not in "Advanced Driver" mode */ 1159 USB_DEVICE(0x0582, 0x0042), 1160 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1161 .vendor_name = "Roland", 1162 .product_name = "RS-70", 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 /* has ID 0x0049 when not in "Advanced Driver" mode */ 1173 USB_DEVICE(0x0582, 0x0047), 1174 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1175 /* .vendor_name = "EDIROL", */ 1176 /* .product_name = "UR-80", */ 1177 .ifnum = QUIRK_ANY_INTERFACE, 1178 .type = QUIRK_COMPOSITE, 1179 .data = (const struct snd_usb_audio_quirk[]) { 1180 /* in the 96 kHz modes, only interface 1 is there */ 1181 { 1182 .ifnum = 1, 1183 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1184 }, 1185 { 1186 .ifnum = 2, 1187 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1188 }, 1189 { 1190 .ifnum = -1 1191 } 1192 } 1193 } 1194 }, 1195 { 1196 /* has ID 0x004a when not in "Advanced Driver" mode */ 1197 USB_DEVICE(0x0582, 0x0048), 1198 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1199 /* .vendor_name = "EDIROL", */ 1200 /* .product_name = "UR-80", */ 1201 .ifnum = 0, 1202 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1203 .data = & (const struct snd_usb_midi_endpoint_info) { 1204 .out_cables = 0x0003, 1205 .in_cables = 0x0007 1206 } 1207 } 1208 }, 1209 { 1210 /* has ID 0x004e when not in "Advanced Driver" mode */ 1211 USB_DEVICE(0x0582, 0x004c), 1212 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1213 .vendor_name = "EDIROL", 1214 .product_name = "PCR-A", 1215 .ifnum = QUIRK_ANY_INTERFACE, 1216 .type = QUIRK_COMPOSITE, 1217 .data = (const struct snd_usb_audio_quirk[]) { 1218 { 1219 .ifnum = 1, 1220 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1221 }, 1222 { 1223 .ifnum = 2, 1224 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1225 }, 1226 { 1227 .ifnum = -1 1228 } 1229 } 1230 } 1231 }, 1232 { 1233 /* has ID 0x004f when not in "Advanced Driver" mode */ 1234 USB_DEVICE(0x0582, 0x004d), 1235 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1236 .vendor_name = "EDIROL", 1237 .product_name = "PCR-A", 1238 .ifnum = 0, 1239 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1240 .data = & (const struct snd_usb_midi_endpoint_info) { 1241 .out_cables = 0x0003, 1242 .in_cables = 0x0007 1243 } 1244 } 1245 }, 1246 { 1247 /* 1248 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX 1249 * is standard compliant, but has only 16-bit PCM. 1250 */ 1251 USB_DEVICE(0x0582, 0x0050), 1252 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1253 .vendor_name = "EDIROL", 1254 .product_name = "UA-3FX", 1255 .ifnum = QUIRK_ANY_INTERFACE, 1256 .type = QUIRK_COMPOSITE, 1257 .data = (const struct snd_usb_audio_quirk[]) { 1258 { 1259 .ifnum = 1, 1260 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1261 }, 1262 { 1263 .ifnum = 2, 1264 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1265 }, 1266 { 1267 .ifnum = -1 1268 } 1269 } 1270 } 1271 }, 1272 { 1273 USB_DEVICE(0x0582, 0x0052), 1274 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1275 .vendor_name = "EDIROL", 1276 .product_name = "UM-1SX", 1277 .ifnum = 0, 1278 .type = QUIRK_MIDI_STANDARD_INTERFACE 1279 } 1280 }, 1281 { 1282 USB_DEVICE(0x0582, 0x0060), 1283 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1284 .vendor_name = "Roland", 1285 .product_name = "EXR Series", 1286 .ifnum = 0, 1287 .type = QUIRK_MIDI_STANDARD_INTERFACE 1288 } 1289 }, 1290 { 1291 /* has ID 0x0066 when not in "Advanced Driver" mode */ 1292 USB_DEVICE(0x0582, 0x0064), 1293 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1294 /* .vendor_name = "EDIROL", */ 1295 /* .product_name = "PCR-1", */ 1296 .ifnum = QUIRK_ANY_INTERFACE, 1297 .type = QUIRK_COMPOSITE, 1298 .data = (const struct snd_usb_audio_quirk[]) { 1299 { 1300 .ifnum = 1, 1301 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1302 }, 1303 { 1304 .ifnum = 2, 1305 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1306 }, 1307 { 1308 .ifnum = -1 1309 } 1310 } 1311 } 1312 }, 1313 { 1314 /* has ID 0x0067 when not in "Advanced Driver" mode */ 1315 USB_DEVICE(0x0582, 0x0065), 1316 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1317 /* .vendor_name = "EDIROL", */ 1318 /* .product_name = "PCR-1", */ 1319 .ifnum = 0, 1320 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1321 .data = & (const struct snd_usb_midi_endpoint_info) { 1322 .out_cables = 0x0001, 1323 .in_cables = 0x0003 1324 } 1325 } 1326 }, 1327 { 1328 /* has ID 0x006e when not in "Advanced Driver" mode */ 1329 USB_DEVICE(0x0582, 0x006d), 1330 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1331 .vendor_name = "Roland", 1332 .product_name = "FANTOM-X", 1333 .ifnum = 0, 1334 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1335 .data = & (const struct snd_usb_midi_endpoint_info) { 1336 .out_cables = 0x0001, 1337 .in_cables = 0x0001 1338 } 1339 } 1340 }, 1341 { /* 1342 * This quirk is for the "Advanced" modes of the Edirol UA-25. 1343 * If the switch is not in an advanced setting, the UA-25 has 1344 * ID 0x0582/0x0073 and is standard compliant (no quirks), but 1345 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1346 */ 1347 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074), 1348 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1349 .vendor_name = "EDIROL", 1350 .product_name = "UA-25", 1351 .ifnum = QUIRK_ANY_INTERFACE, 1352 .type = QUIRK_COMPOSITE, 1353 .data = (const struct snd_usb_audio_quirk[]) { 1354 { 1355 .ifnum = 0, 1356 .type = QUIRK_AUDIO_EDIROL_UAXX 1357 }, 1358 { 1359 .ifnum = 1, 1360 .type = QUIRK_AUDIO_EDIROL_UAXX 1361 }, 1362 { 1363 .ifnum = 2, 1364 .type = QUIRK_AUDIO_EDIROL_UAXX 1365 }, 1366 { 1367 .ifnum = -1 1368 } 1369 } 1370 } 1371 }, 1372 { 1373 /* has ID 0x0076 when not in "Advanced Driver" mode */ 1374 USB_DEVICE(0x0582, 0x0075), 1375 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1376 .vendor_name = "BOSS", 1377 .product_name = "DR-880", 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 = 0x0001 1383 } 1384 } 1385 }, 1386 { 1387 /* has ID 0x007b when not in "Advanced Driver" mode */ 1388 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a), 1389 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1390 .vendor_name = "Roland", 1391 /* "RD" or "RD-700SX"? */ 1392 .ifnum = 0, 1393 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1394 .data = & (const struct snd_usb_midi_endpoint_info) { 1395 .out_cables = 0x0003, 1396 .in_cables = 0x0003 1397 } 1398 } 1399 }, 1400 { 1401 /* has ID 0x0081 when not in "Advanced Driver" mode */ 1402 USB_DEVICE(0x0582, 0x0080), 1403 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1404 .vendor_name = "Roland", 1405 .product_name = "G-70", 1406 .ifnum = 0, 1407 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1408 .data = & (const struct snd_usb_midi_endpoint_info) { 1409 .out_cables = 0x0001, 1410 .in_cables = 0x0001 1411 } 1412 } 1413 }, 1414 { 1415 /* has ID 0x008c when not in "Advanced Driver" mode */ 1416 USB_DEVICE(0x0582, 0x008b), 1417 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1418 .vendor_name = "EDIROL", 1419 .product_name = "PC-50", 1420 .ifnum = 0, 1421 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1422 .data = & (const struct snd_usb_midi_endpoint_info) { 1423 .out_cables = 0x0001, 1424 .in_cables = 0x0001 1425 } 1426 } 1427 }, 1428 { 1429 /* 1430 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX 1431 * is standard compliant, but has only 16-bit PCM and no MIDI. 1432 */ 1433 USB_DEVICE(0x0582, 0x00a3), 1434 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1435 .vendor_name = "EDIROL", 1436 .product_name = "UA-4FX", 1437 .ifnum = QUIRK_ANY_INTERFACE, 1438 .type = QUIRK_COMPOSITE, 1439 .data = (const struct snd_usb_audio_quirk[]) { 1440 { 1441 .ifnum = 0, 1442 .type = QUIRK_AUDIO_EDIROL_UAXX 1443 }, 1444 { 1445 .ifnum = 1, 1446 .type = QUIRK_AUDIO_EDIROL_UAXX 1447 }, 1448 { 1449 .ifnum = 2, 1450 .type = QUIRK_AUDIO_EDIROL_UAXX 1451 }, 1452 { 1453 .ifnum = -1 1454 } 1455 } 1456 } 1457 }, 1458 { 1459 /* Edirol M-16DX */ 1460 USB_DEVICE(0x0582, 0x00c4), 1461 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1462 .ifnum = QUIRK_ANY_INTERFACE, 1463 .type = QUIRK_COMPOSITE, 1464 .data = (const struct snd_usb_audio_quirk[]) { 1465 { 1466 .ifnum = 0, 1467 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1468 }, 1469 { 1470 .ifnum = 1, 1471 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1472 }, 1473 { 1474 .ifnum = 2, 1475 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1476 .data = & (const struct snd_usb_midi_endpoint_info) { 1477 .out_cables = 0x0001, 1478 .in_cables = 0x0001 1479 } 1480 }, 1481 { 1482 .ifnum = -1 1483 } 1484 } 1485 } 1486 }, 1487 { 1488 /* Advanced modes of the Edirol UA-25EX. 1489 * For the standard mode, UA-25EX has ID 0582:00e7, which 1490 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1491 */ 1492 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6), 1493 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1494 .vendor_name = "EDIROL", 1495 .product_name = "UA-25EX", 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 UM-3G */ 1519 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108), 1520 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1521 .ifnum = 0, 1522 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1523 .data = & (const struct snd_usb_midi_endpoint_info) { 1524 .out_cables = 0x0007, 1525 .in_cables = 0x0007 1526 } 1527 } 1528 }, 1529 { 1530 /* BOSS ME-25 */ 1531 USB_DEVICE(0x0582, 0x0113), 1532 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1533 .ifnum = QUIRK_ANY_INTERFACE, 1534 .type = QUIRK_COMPOSITE, 1535 .data = (const struct snd_usb_audio_quirk[]) { 1536 { 1537 .ifnum = 0, 1538 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1539 }, 1540 { 1541 .ifnum = 1, 1542 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1543 }, 1544 { 1545 .ifnum = 2, 1546 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1547 .data = & (const struct snd_usb_midi_endpoint_info) { 1548 .out_cables = 0x0001, 1549 .in_cables = 0x0001 1550 } 1551 }, 1552 { 1553 .ifnum = -1 1554 } 1555 } 1556 } 1557 }, 1558 { 1559 /* only 44.1 kHz works at the moment */ 1560 USB_DEVICE(0x0582, 0x0120), 1561 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1562 /* .vendor_name = "Roland", */ 1563 /* .product_name = "OCTO-CAPTURE", */ 1564 .ifnum = QUIRK_ANY_INTERFACE, 1565 .type = QUIRK_COMPOSITE, 1566 .data = (const struct snd_usb_audio_quirk[]) { 1567 { 1568 .ifnum = 0, 1569 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1570 .data = & (const struct audioformat) { 1571 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1572 .channels = 10, 1573 .iface = 0, 1574 .altsetting = 1, 1575 .altset_idx = 1, 1576 .endpoint = 0x05, 1577 .ep_attr = 0x05, 1578 .rates = SNDRV_PCM_RATE_44100, 1579 .rate_min = 44100, 1580 .rate_max = 44100, 1581 .nr_rates = 1, 1582 .rate_table = (unsigned int[]) { 44100 } 1583 } 1584 }, 1585 { 1586 .ifnum = 1, 1587 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1588 .data = & (const struct audioformat) { 1589 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1590 .channels = 12, 1591 .iface = 1, 1592 .altsetting = 1, 1593 .altset_idx = 1, 1594 .endpoint = 0x85, 1595 .ep_attr = 0x25, 1596 .rates = SNDRV_PCM_RATE_44100, 1597 .rate_min = 44100, 1598 .rate_max = 44100, 1599 .nr_rates = 1, 1600 .rate_table = (unsigned int[]) { 44100 } 1601 } 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 = 3, 1613 .type = QUIRK_IGNORE_INTERFACE 1614 }, 1615 { 1616 .ifnum = 4, 1617 .type = QUIRK_IGNORE_INTERFACE 1618 }, 1619 { 1620 .ifnum = -1 1621 } 1622 } 1623 } 1624 }, 1625 { 1626 /* only 44.1 kHz works at the moment */ 1627 USB_DEVICE(0x0582, 0x012f), 1628 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1629 /* .vendor_name = "Roland", */ 1630 /* .product_name = "QUAD-CAPTURE", */ 1631 .ifnum = QUIRK_ANY_INTERFACE, 1632 .type = QUIRK_COMPOSITE, 1633 .data = (const struct snd_usb_audio_quirk[]) { 1634 { 1635 .ifnum = 0, 1636 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1637 .data = & (const struct audioformat) { 1638 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1639 .channels = 4, 1640 .iface = 0, 1641 .altsetting = 1, 1642 .altset_idx = 1, 1643 .endpoint = 0x05, 1644 .ep_attr = 0x05, 1645 .rates = SNDRV_PCM_RATE_44100, 1646 .rate_min = 44100, 1647 .rate_max = 44100, 1648 .nr_rates = 1, 1649 .rate_table = (unsigned int[]) { 44100 } 1650 } 1651 }, 1652 { 1653 .ifnum = 1, 1654 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1655 .data = & (const struct audioformat) { 1656 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1657 .channels = 6, 1658 .iface = 1, 1659 .altsetting = 1, 1660 .altset_idx = 1, 1661 .endpoint = 0x85, 1662 .ep_attr = 0x25, 1663 .rates = SNDRV_PCM_RATE_44100, 1664 .rate_min = 44100, 1665 .rate_max = 44100, 1666 .nr_rates = 1, 1667 .rate_table = (unsigned int[]) { 44100 } 1668 } 1669 }, 1670 { 1671 .ifnum = 2, 1672 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1673 .data = & (const struct snd_usb_midi_endpoint_info) { 1674 .out_cables = 0x0001, 1675 .in_cables = 0x0001 1676 } 1677 }, 1678 { 1679 .ifnum = 3, 1680 .type = QUIRK_IGNORE_INTERFACE 1681 }, 1682 { 1683 .ifnum = 4, 1684 .type = QUIRK_IGNORE_INTERFACE 1685 }, 1686 { 1687 .ifnum = -1 1688 } 1689 } 1690 } 1691 }, 1692 { 1693 USB_DEVICE(0x0582, 0x0159), 1694 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1695 /* .vendor_name = "Roland", */ 1696 /* .product_name = "UA-22", */ 1697 .ifnum = QUIRK_ANY_INTERFACE, 1698 .type = QUIRK_COMPOSITE, 1699 .data = (const struct snd_usb_audio_quirk[]) { 1700 { 1701 .ifnum = 0, 1702 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1703 }, 1704 { 1705 .ifnum = 1, 1706 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1707 }, 1708 { 1709 .ifnum = 2, 1710 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1711 .data = & (const struct snd_usb_midi_endpoint_info) { 1712 .out_cables = 0x0001, 1713 .in_cables = 0x0001 1714 } 1715 }, 1716 { 1717 .ifnum = -1 1718 } 1719 } 1720 } 1721 }, 1722 1723 /* UA101 and co are supported by another driver */ 1724 { 1725 USB_DEVICE(0x0582, 0x0044), /* UA-1000 high speed */ 1726 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1727 .ifnum = QUIRK_NODEV_INTERFACE 1728 }, 1729 }, 1730 { 1731 USB_DEVICE(0x0582, 0x007d), /* UA-101 high speed */ 1732 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1733 .ifnum = QUIRK_NODEV_INTERFACE 1734 }, 1735 }, 1736 { 1737 USB_DEVICE(0x0582, 0x008d), /* UA-101 full speed */ 1738 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1739 .ifnum = QUIRK_NODEV_INTERFACE 1740 }, 1741 }, 1742 1743 /* this catches most recent vendor-specific Roland devices */ 1744 { 1745 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 1746 USB_DEVICE_ID_MATCH_INT_CLASS, 1747 .idVendor = 0x0582, 1748 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 1749 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 1750 .ifnum = QUIRK_ANY_INTERFACE, 1751 .type = QUIRK_AUTODETECT 1752 } 1753 }, 1754 1755 /* Guillemot devices */ 1756 { 1757 /* 1758 * This is for the "Windows Edition" where the external MIDI ports are 1759 * the only MIDI ports; the control data is reported through HID 1760 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1761 * compliant USB MIDI ports for external MIDI and controls. 1762 */ 1763 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1764 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1765 .vendor_name = "Hercules", 1766 .product_name = "DJ Console (WE)", 1767 .ifnum = 4, 1768 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1769 .data = & (const struct snd_usb_midi_endpoint_info) { 1770 .out_cables = 0x0001, 1771 .in_cables = 0x0001 1772 } 1773 } 1774 }, 1775 1776 /* Midiman/M-Audio devices */ 1777 { 1778 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1779 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1780 .vendor_name = "M-Audio", 1781 .product_name = "MidiSport 2x2", 1782 .ifnum = QUIRK_ANY_INTERFACE, 1783 .type = QUIRK_MIDI_MIDIMAN, 1784 .data = & (const struct snd_usb_midi_endpoint_info) { 1785 .out_cables = 0x0003, 1786 .in_cables = 0x0003 1787 } 1788 } 1789 }, 1790 { 1791 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1792 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1793 .vendor_name = "M-Audio", 1794 .product_name = "MidiSport 1x1", 1795 .ifnum = QUIRK_ANY_INTERFACE, 1796 .type = QUIRK_MIDI_MIDIMAN, 1797 .data = & (const struct snd_usb_midi_endpoint_info) { 1798 .out_cables = 0x0001, 1799 .in_cables = 0x0001 1800 } 1801 } 1802 }, 1803 { 1804 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1805 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1806 .vendor_name = "M-Audio", 1807 .product_name = "Keystation", 1808 .ifnum = QUIRK_ANY_INTERFACE, 1809 .type = QUIRK_MIDI_MIDIMAN, 1810 .data = & (const struct snd_usb_midi_endpoint_info) { 1811 .out_cables = 0x0001, 1812 .in_cables = 0x0001 1813 } 1814 } 1815 }, 1816 { 1817 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1818 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1819 .vendor_name = "M-Audio", 1820 .product_name = "MidiSport 4x4", 1821 .ifnum = QUIRK_ANY_INTERFACE, 1822 .type = QUIRK_MIDI_MIDIMAN, 1823 .data = & (const struct snd_usb_midi_endpoint_info) { 1824 .out_cables = 0x000f, 1825 .in_cables = 0x000f 1826 } 1827 } 1828 }, 1829 { 1830 /* 1831 * For hardware revision 1.05; in the later revisions (1.10 and 1832 * 1.21), 0x1031 is the ID for the device without firmware. 1833 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1834 */ 1835 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1836 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1837 .vendor_name = "M-Audio", 1838 .product_name = "MidiSport 8x8", 1839 .ifnum = QUIRK_ANY_INTERFACE, 1840 .type = QUIRK_MIDI_MIDIMAN, 1841 .data = & (const struct snd_usb_midi_endpoint_info) { 1842 .out_cables = 0x01ff, 1843 .in_cables = 0x01ff 1844 } 1845 } 1846 }, 1847 { 1848 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1849 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1850 .vendor_name = "M-Audio", 1851 .product_name = "MidiSport 8x8", 1852 .ifnum = QUIRK_ANY_INTERFACE, 1853 .type = QUIRK_MIDI_MIDIMAN, 1854 .data = & (const struct snd_usb_midi_endpoint_info) { 1855 .out_cables = 0x01ff, 1856 .in_cables = 0x01ff 1857 } 1858 } 1859 }, 1860 { 1861 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1862 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1863 .vendor_name = "M-Audio", 1864 .product_name = "MidiSport 2x4", 1865 .ifnum = QUIRK_ANY_INTERFACE, 1866 .type = QUIRK_MIDI_MIDIMAN, 1867 .data = & (const struct snd_usb_midi_endpoint_info) { 1868 .out_cables = 0x000f, 1869 .in_cables = 0x0003 1870 } 1871 } 1872 }, 1873 { 1874 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1875 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1876 .vendor_name = "M-Audio", 1877 .product_name = "Quattro", 1878 .ifnum = QUIRK_ANY_INTERFACE, 1879 .type = QUIRK_COMPOSITE, 1880 .data = & (const struct snd_usb_audio_quirk[]) { 1881 /* 1882 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1883 * and share endpoints with the other interfaces. 1884 * Ignore them. The other interfaces can do 24 bits, 1885 * but captured samples are big-endian (see usbaudio.c). 1886 */ 1887 { 1888 .ifnum = 0, 1889 .type = QUIRK_IGNORE_INTERFACE 1890 }, 1891 { 1892 .ifnum = 1, 1893 .type = QUIRK_IGNORE_INTERFACE 1894 }, 1895 { 1896 .ifnum = 2, 1897 .type = QUIRK_IGNORE_INTERFACE 1898 }, 1899 { 1900 .ifnum = 3, 1901 .type = QUIRK_IGNORE_INTERFACE 1902 }, 1903 { 1904 .ifnum = 4, 1905 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1906 }, 1907 { 1908 .ifnum = 5, 1909 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1910 }, 1911 { 1912 .ifnum = 6, 1913 .type = QUIRK_IGNORE_INTERFACE 1914 }, 1915 { 1916 .ifnum = 7, 1917 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1918 }, 1919 { 1920 .ifnum = 8, 1921 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1922 }, 1923 { 1924 .ifnum = 9, 1925 .type = QUIRK_MIDI_MIDIMAN, 1926 .data = & (const struct snd_usb_midi_endpoint_info) { 1927 .out_cables = 0x0001, 1928 .in_cables = 0x0001 1929 } 1930 }, 1931 { 1932 .ifnum = -1 1933 } 1934 } 1935 } 1936 }, 1937 { 1938 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 1939 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1940 .vendor_name = "M-Audio", 1941 .product_name = "AudioPhile", 1942 .ifnum = 6, 1943 .type = QUIRK_MIDI_MIDIMAN, 1944 .data = & (const struct snd_usb_midi_endpoint_info) { 1945 .out_cables = 0x0001, 1946 .in_cables = 0x0001 1947 } 1948 } 1949 }, 1950 { 1951 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 1952 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1953 .vendor_name = "M-Audio", 1954 .product_name = "Ozone", 1955 .ifnum = 3, 1956 .type = QUIRK_MIDI_MIDIMAN, 1957 .data = & (const struct snd_usb_midi_endpoint_info) { 1958 .out_cables = 0x0001, 1959 .in_cables = 0x0001 1960 } 1961 } 1962 }, 1963 { 1964 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 1965 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1966 .vendor_name = "M-Audio", 1967 .product_name = "OmniStudio", 1968 .ifnum = QUIRK_ANY_INTERFACE, 1969 .type = QUIRK_COMPOSITE, 1970 .data = & (const struct snd_usb_audio_quirk[]) { 1971 { 1972 .ifnum = 0, 1973 .type = QUIRK_IGNORE_INTERFACE 1974 }, 1975 { 1976 .ifnum = 1, 1977 .type = QUIRK_IGNORE_INTERFACE 1978 }, 1979 { 1980 .ifnum = 2, 1981 .type = QUIRK_IGNORE_INTERFACE 1982 }, 1983 { 1984 .ifnum = 3, 1985 .type = QUIRK_IGNORE_INTERFACE 1986 }, 1987 { 1988 .ifnum = 4, 1989 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1990 }, 1991 { 1992 .ifnum = 5, 1993 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1994 }, 1995 { 1996 .ifnum = 6, 1997 .type = QUIRK_IGNORE_INTERFACE 1998 }, 1999 { 2000 .ifnum = 7, 2001 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2002 }, 2003 { 2004 .ifnum = 8, 2005 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2006 }, 2007 { 2008 .ifnum = 9, 2009 .type = QUIRK_MIDI_MIDIMAN, 2010 .data = & (const struct snd_usb_midi_endpoint_info) { 2011 .out_cables = 0x0001, 2012 .in_cables = 0x0001 2013 } 2014 }, 2015 { 2016 .ifnum = -1 2017 } 2018 } 2019 } 2020 }, 2021 { 2022 USB_DEVICE(0x0763, 0x2019), 2023 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2024 /* .vendor_name = "M-Audio", */ 2025 /* .product_name = "Ozone Academic", */ 2026 .ifnum = QUIRK_ANY_INTERFACE, 2027 .type = QUIRK_COMPOSITE, 2028 .data = & (const struct snd_usb_audio_quirk[]) { 2029 { 2030 .ifnum = 0, 2031 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2032 }, 2033 { 2034 .ifnum = 1, 2035 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2036 }, 2037 { 2038 .ifnum = 2, 2039 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2040 }, 2041 { 2042 .ifnum = 3, 2043 .type = QUIRK_MIDI_MIDIMAN, 2044 .data = & (const struct snd_usb_midi_endpoint_info) { 2045 .out_cables = 0x0001, 2046 .in_cables = 0x0001 2047 } 2048 }, 2049 { 2050 .ifnum = -1 2051 } 2052 } 2053 } 2054 }, 2055 { 2056 /* M-Audio Micro */ 2057 USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a), 2058 }, 2059 { 2060 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030), 2061 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2062 /* .vendor_name = "M-Audio", */ 2063 /* .product_name = "Fast Track C400", */ 2064 .ifnum = QUIRK_ANY_INTERFACE, 2065 .type = QUIRK_COMPOSITE, 2066 .data = &(const struct snd_usb_audio_quirk[]) { 2067 { 2068 .ifnum = 1, 2069 .type = QUIRK_AUDIO_STANDARD_MIXER, 2070 }, 2071 /* Playback */ 2072 { 2073 .ifnum = 2, 2074 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2075 .data = &(const struct audioformat) { 2076 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2077 .channels = 6, 2078 .iface = 2, 2079 .altsetting = 1, 2080 .altset_idx = 1, 2081 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2082 .endpoint = 0x01, 2083 .ep_attr = 0x09, 2084 .rates = SNDRV_PCM_RATE_44100 | 2085 SNDRV_PCM_RATE_48000 | 2086 SNDRV_PCM_RATE_88200 | 2087 SNDRV_PCM_RATE_96000, 2088 .rate_min = 44100, 2089 .rate_max = 96000, 2090 .nr_rates = 4, 2091 .rate_table = (unsigned int[]) { 2092 44100, 48000, 88200, 96000 2093 }, 2094 .clock = 0x80, 2095 } 2096 }, 2097 /* Capture */ 2098 { 2099 .ifnum = 3, 2100 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2101 .data = &(const struct audioformat) { 2102 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2103 .channels = 4, 2104 .iface = 3, 2105 .altsetting = 1, 2106 .altset_idx = 1, 2107 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2108 .endpoint = 0x81, 2109 .ep_attr = 0x05, 2110 .rates = SNDRV_PCM_RATE_44100 | 2111 SNDRV_PCM_RATE_48000 | 2112 SNDRV_PCM_RATE_88200 | 2113 SNDRV_PCM_RATE_96000, 2114 .rate_min = 44100, 2115 .rate_max = 96000, 2116 .nr_rates = 4, 2117 .rate_table = (unsigned int[]) { 2118 44100, 48000, 88200, 96000 2119 }, 2120 .clock = 0x80, 2121 } 2122 }, 2123 /* MIDI */ 2124 { 2125 .ifnum = -1 /* Interface = 4 */ 2126 } 2127 } 2128 } 2129 }, 2130 { 2131 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031), 2132 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2133 /* .vendor_name = "M-Audio", */ 2134 /* .product_name = "Fast Track C600", */ 2135 .ifnum = QUIRK_ANY_INTERFACE, 2136 .type = QUIRK_COMPOSITE, 2137 .data = &(const struct snd_usb_audio_quirk[]) { 2138 { 2139 .ifnum = 1, 2140 .type = QUIRK_AUDIO_STANDARD_MIXER, 2141 }, 2142 /* Playback */ 2143 { 2144 .ifnum = 2, 2145 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2146 .data = &(const struct audioformat) { 2147 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2148 .channels = 8, 2149 .iface = 2, 2150 .altsetting = 1, 2151 .altset_idx = 1, 2152 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2153 .endpoint = 0x01, 2154 .ep_attr = 0x09, 2155 .rates = SNDRV_PCM_RATE_44100 | 2156 SNDRV_PCM_RATE_48000 | 2157 SNDRV_PCM_RATE_88200 | 2158 SNDRV_PCM_RATE_96000, 2159 .rate_min = 44100, 2160 .rate_max = 96000, 2161 .nr_rates = 4, 2162 .rate_table = (unsigned int[]) { 2163 44100, 48000, 88200, 96000 2164 }, 2165 .clock = 0x80, 2166 } 2167 }, 2168 /* Capture */ 2169 { 2170 .ifnum = 3, 2171 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2172 .data = &(const struct audioformat) { 2173 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2174 .channels = 6, 2175 .iface = 3, 2176 .altsetting = 1, 2177 .altset_idx = 1, 2178 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2179 .endpoint = 0x81, 2180 .ep_attr = 0x05, 2181 .rates = SNDRV_PCM_RATE_44100 | 2182 SNDRV_PCM_RATE_48000 | 2183 SNDRV_PCM_RATE_88200 | 2184 SNDRV_PCM_RATE_96000, 2185 .rate_min = 44100, 2186 .rate_max = 96000, 2187 .nr_rates = 4, 2188 .rate_table = (unsigned int[]) { 2189 44100, 48000, 88200, 96000 2190 }, 2191 .clock = 0x80, 2192 } 2193 }, 2194 /* MIDI */ 2195 { 2196 .ifnum = -1 /* Interface = 4 */ 2197 } 2198 } 2199 } 2200 }, 2201 { 2202 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080), 2203 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2204 /* .vendor_name = "M-Audio", */ 2205 /* .product_name = "Fast Track Ultra", */ 2206 .ifnum = QUIRK_ANY_INTERFACE, 2207 .type = QUIRK_COMPOSITE, 2208 .data = & (const struct snd_usb_audio_quirk[]) { 2209 { 2210 .ifnum = 0, 2211 .type = QUIRK_AUDIO_STANDARD_MIXER, 2212 }, 2213 { 2214 .ifnum = 1, 2215 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2216 .data = & (const struct audioformat) { 2217 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2218 .channels = 8, 2219 .iface = 1, 2220 .altsetting = 1, 2221 .altset_idx = 1, 2222 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2223 .endpoint = 0x01, 2224 .ep_attr = 0x09, 2225 .rates = SNDRV_PCM_RATE_44100 | 2226 SNDRV_PCM_RATE_48000 | 2227 SNDRV_PCM_RATE_88200 | 2228 SNDRV_PCM_RATE_96000, 2229 .rate_min = 44100, 2230 .rate_max = 96000, 2231 .nr_rates = 4, 2232 .rate_table = (unsigned int[]) { 2233 44100, 48000, 88200, 96000 2234 } 2235 } 2236 }, 2237 { 2238 .ifnum = 2, 2239 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2240 .data = & (const struct audioformat) { 2241 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2242 .channels = 8, 2243 .iface = 2, 2244 .altsetting = 1, 2245 .altset_idx = 1, 2246 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2247 .endpoint = 0x81, 2248 .ep_attr = 0x05, 2249 .rates = SNDRV_PCM_RATE_44100 | 2250 SNDRV_PCM_RATE_48000 | 2251 SNDRV_PCM_RATE_88200 | 2252 SNDRV_PCM_RATE_96000, 2253 .rate_min = 44100, 2254 .rate_max = 96000, 2255 .nr_rates = 4, 2256 .rate_table = (unsigned int[]) { 2257 44100, 48000, 88200, 96000 2258 } 2259 } 2260 }, 2261 /* interface 3 (MIDI) is standard compliant */ 2262 { 2263 .ifnum = -1 2264 } 2265 } 2266 } 2267 }, 2268 { 2269 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2270 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2271 /* .vendor_name = "M-Audio", */ 2272 /* .product_name = "Fast Track Ultra 8R", */ 2273 .ifnum = QUIRK_ANY_INTERFACE, 2274 .type = QUIRK_COMPOSITE, 2275 .data = & (const struct snd_usb_audio_quirk[]) { 2276 { 2277 .ifnum = 0, 2278 .type = QUIRK_AUDIO_STANDARD_MIXER, 2279 }, 2280 { 2281 .ifnum = 1, 2282 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2283 .data = & (const struct audioformat) { 2284 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2285 .channels = 8, 2286 .iface = 1, 2287 .altsetting = 1, 2288 .altset_idx = 1, 2289 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2290 .endpoint = 0x01, 2291 .ep_attr = 0x09, 2292 .rates = SNDRV_PCM_RATE_44100 | 2293 SNDRV_PCM_RATE_48000 | 2294 SNDRV_PCM_RATE_88200 | 2295 SNDRV_PCM_RATE_96000, 2296 .rate_min = 44100, 2297 .rate_max = 96000, 2298 .nr_rates = 4, 2299 .rate_table = (unsigned int[]) { 2300 44100, 48000, 88200, 96000 2301 } 2302 } 2303 }, 2304 { 2305 .ifnum = 2, 2306 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2307 .data = & (const struct audioformat) { 2308 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2309 .channels = 8, 2310 .iface = 2, 2311 .altsetting = 1, 2312 .altset_idx = 1, 2313 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2314 .endpoint = 0x81, 2315 .ep_attr = 0x05, 2316 .rates = SNDRV_PCM_RATE_44100 | 2317 SNDRV_PCM_RATE_48000 | 2318 SNDRV_PCM_RATE_88200 | 2319 SNDRV_PCM_RATE_96000, 2320 .rate_min = 44100, 2321 .rate_max = 96000, 2322 .nr_rates = 4, 2323 .rate_table = (unsigned int[]) { 2324 44100, 48000, 88200, 96000 2325 } 2326 } 2327 }, 2328 /* interface 3 (MIDI) is standard compliant */ 2329 { 2330 .ifnum = -1 2331 } 2332 } 2333 } 2334 }, 2335 2336 /* Casio devices */ 2337 { 2338 USB_DEVICE(0x07cf, 0x6801), 2339 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2340 .vendor_name = "Casio", 2341 .product_name = "PL-40R", 2342 .ifnum = 0, 2343 .type = QUIRK_MIDI_YAMAHA 2344 } 2345 }, 2346 { 2347 /* this ID is used by several devices without a product ID */ 2348 USB_DEVICE(0x07cf, 0x6802), 2349 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2350 .vendor_name = "Casio", 2351 .product_name = "Keyboard", 2352 .ifnum = 0, 2353 .type = QUIRK_MIDI_YAMAHA 2354 } 2355 }, 2356 2357 /* Mark of the Unicorn devices */ 2358 { 2359 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2360 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2361 USB_DEVICE_ID_MATCH_PRODUCT | 2362 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2363 .idVendor = 0x07fd, 2364 .idProduct = 0x0001, 2365 .bDeviceSubClass = 2, 2366 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2367 .vendor_name = "MOTU", 2368 .product_name = "Fastlane", 2369 .ifnum = QUIRK_ANY_INTERFACE, 2370 .type = QUIRK_COMPOSITE, 2371 .data = & (const struct snd_usb_audio_quirk[]) { 2372 { 2373 .ifnum = 0, 2374 .type = QUIRK_MIDI_RAW_BYTES 2375 }, 2376 { 2377 .ifnum = 1, 2378 .type = QUIRK_IGNORE_INTERFACE 2379 }, 2380 { 2381 .ifnum = -1 2382 } 2383 } 2384 } 2385 }, 2386 2387 /* Emagic devices */ 2388 { 2389 USB_DEVICE(0x086a, 0x0001), 2390 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2391 .vendor_name = "Emagic", 2392 .product_name = "Unitor8", 2393 .ifnum = 2, 2394 .type = QUIRK_MIDI_EMAGIC, 2395 .data = & (const struct snd_usb_midi_endpoint_info) { 2396 .out_cables = 0x80ff, 2397 .in_cables = 0x80ff 2398 } 2399 } 2400 }, 2401 { 2402 USB_DEVICE(0x086a, 0x0002), 2403 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2404 .vendor_name = "Emagic", 2405 /* .product_name = "AMT8", */ 2406 .ifnum = 2, 2407 .type = QUIRK_MIDI_EMAGIC, 2408 .data = & (const struct snd_usb_midi_endpoint_info) { 2409 .out_cables = 0x80ff, 2410 .in_cables = 0x80ff 2411 } 2412 } 2413 }, 2414 { 2415 USB_DEVICE(0x086a, 0x0003), 2416 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2417 .vendor_name = "Emagic", 2418 /* .product_name = "MT4", */ 2419 .ifnum = 2, 2420 .type = QUIRK_MIDI_EMAGIC, 2421 .data = & (const struct snd_usb_midi_endpoint_info) { 2422 .out_cables = 0x800f, 2423 .in_cables = 0x8003 2424 } 2425 } 2426 }, 2427 2428 /* KORG devices */ 2429 { 2430 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2431 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2432 .vendor_name = "KORG, Inc.", 2433 /* .product_name = "PANDORA PX5D", */ 2434 .ifnum = 3, 2435 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2436 } 2437 }, 2438 2439 { 2440 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201), 2441 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2442 .vendor_name = "KORG, Inc.", 2443 /* .product_name = "ToneLab ST", */ 2444 .ifnum = 3, 2445 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2446 } 2447 }, 2448 2449 { 2450 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204), 2451 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2452 .vendor_name = "KORG, Inc.", 2453 /* .product_name = "ToneLab EX", */ 2454 .ifnum = 3, 2455 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2456 } 2457 }, 2458 2459 /* AKAI devices */ 2460 { 2461 USB_DEVICE(0x09e8, 0x0062), 2462 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2463 .vendor_name = "AKAI", 2464 .product_name = "MPD16", 2465 .ifnum = 0, 2466 .type = QUIRK_MIDI_AKAI, 2467 } 2468 }, 2469 2470 { 2471 /* Akai MPC Element */ 2472 USB_DEVICE(0x09e8, 0x0021), 2473 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2474 .ifnum = QUIRK_ANY_INTERFACE, 2475 .type = QUIRK_COMPOSITE, 2476 .data = & (const struct snd_usb_audio_quirk[]) { 2477 { 2478 .ifnum = 0, 2479 .type = QUIRK_IGNORE_INTERFACE 2480 }, 2481 { 2482 .ifnum = 1, 2483 .type = QUIRK_MIDI_STANDARD_INTERFACE 2484 }, 2485 { 2486 .ifnum = -1 2487 } 2488 } 2489 } 2490 }, 2491 2492 /* Steinberg devices */ 2493 { 2494 /* Steinberg MI2 */ 2495 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040), 2496 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2497 .ifnum = QUIRK_ANY_INTERFACE, 2498 .type = QUIRK_COMPOSITE, 2499 .data = & (const struct snd_usb_audio_quirk[]) { 2500 { 2501 .ifnum = 0, 2502 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2503 }, 2504 { 2505 .ifnum = 1, 2506 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2507 }, 2508 { 2509 .ifnum = 2, 2510 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2511 }, 2512 { 2513 .ifnum = 3, 2514 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2515 .data = &(const struct snd_usb_midi_endpoint_info) { 2516 .out_cables = 0x0001, 2517 .in_cables = 0x0001 2518 } 2519 }, 2520 { 2521 .ifnum = -1 2522 } 2523 } 2524 } 2525 }, 2526 { 2527 /* Steinberg MI4 */ 2528 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040), 2529 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2530 .ifnum = QUIRK_ANY_INTERFACE, 2531 .type = QUIRK_COMPOSITE, 2532 .data = & (const struct snd_usb_audio_quirk[]) { 2533 { 2534 .ifnum = 0, 2535 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2536 }, 2537 { 2538 .ifnum = 1, 2539 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2540 }, 2541 { 2542 .ifnum = 2, 2543 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2544 }, 2545 { 2546 .ifnum = 3, 2547 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2548 .data = &(const struct snd_usb_midi_endpoint_info) { 2549 .out_cables = 0x0001, 2550 .in_cables = 0x0001 2551 } 2552 }, 2553 { 2554 .ifnum = -1 2555 } 2556 } 2557 } 2558 }, 2559 2560 /* TerraTec devices */ 2561 { 2562 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2563 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2564 .vendor_name = "TerraTec", 2565 .product_name = "PHASE 26", 2566 .ifnum = 3, 2567 .type = QUIRK_MIDI_STANDARD_INTERFACE 2568 } 2569 }, 2570 { 2571 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2572 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2573 .vendor_name = "TerraTec", 2574 .product_name = "PHASE 26", 2575 .ifnum = 3, 2576 .type = QUIRK_MIDI_STANDARD_INTERFACE 2577 } 2578 }, 2579 { 2580 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2581 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2582 .vendor_name = "TerraTec", 2583 .product_name = "PHASE 26", 2584 .ifnum = 3, 2585 .type = QUIRK_MIDI_STANDARD_INTERFACE 2586 } 2587 }, 2588 { 2589 USB_DEVICE(0x0ccd, 0x0035), 2590 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2591 .vendor_name = "Miditech", 2592 .product_name = "Play'n Roll", 2593 .ifnum = 0, 2594 .type = QUIRK_MIDI_CME 2595 } 2596 }, 2597 2598 /* Stanton ScratchAmp */ 2599 { USB_DEVICE(0x103d, 0x0100) }, 2600 { USB_DEVICE(0x103d, 0x0101) }, 2601 2602 /* Novation EMS devices */ 2603 { 2604 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2605 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2606 .vendor_name = "Novation", 2607 .product_name = "ReMOTE Audio/XStation", 2608 .ifnum = 4, 2609 .type = QUIRK_MIDI_NOVATION 2610 } 2611 }, 2612 { 2613 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2614 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2615 .vendor_name = "Novation", 2616 .product_name = "Speedio", 2617 .ifnum = 3, 2618 .type = QUIRK_MIDI_NOVATION 2619 } 2620 }, 2621 { 2622 USB_DEVICE(0x1235, 0x000a), 2623 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2624 /* .vendor_name = "Novation", */ 2625 /* .product_name = "Nocturn", */ 2626 .ifnum = 0, 2627 .type = QUIRK_MIDI_RAW_BYTES 2628 } 2629 }, 2630 { 2631 USB_DEVICE(0x1235, 0x000e), 2632 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2633 /* .vendor_name = "Novation", */ 2634 /* .product_name = "Launchpad", */ 2635 .ifnum = 0, 2636 .type = QUIRK_MIDI_RAW_BYTES 2637 } 2638 }, 2639 { 2640 USB_DEVICE(0x1235, 0x0010), 2641 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2642 .vendor_name = "Focusrite", 2643 .product_name = "Saffire 6 USB", 2644 .ifnum = QUIRK_ANY_INTERFACE, 2645 .type = QUIRK_COMPOSITE, 2646 .data = (const struct snd_usb_audio_quirk[]) { 2647 { 2648 .ifnum = 0, 2649 .type = QUIRK_AUDIO_STANDARD_MIXER, 2650 }, 2651 { 2652 .ifnum = 0, 2653 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2654 .data = &(const struct audioformat) { 2655 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2656 .channels = 4, 2657 .iface = 0, 2658 .altsetting = 1, 2659 .altset_idx = 1, 2660 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2661 .endpoint = 0x01, 2662 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2663 .datainterval = 1, 2664 .maxpacksize = 0x024c, 2665 .rates = SNDRV_PCM_RATE_44100 | 2666 SNDRV_PCM_RATE_48000, 2667 .rate_min = 44100, 2668 .rate_max = 48000, 2669 .nr_rates = 2, 2670 .rate_table = (unsigned int[]) { 2671 44100, 48000 2672 }, 2673 .sync_ep = 0x82, 2674 .sync_iface = 0, 2675 .sync_altsetting = 1, 2676 .sync_ep_idx = 1, 2677 .implicit_fb = 1, 2678 } 2679 }, 2680 { 2681 .ifnum = 0, 2682 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2683 .data = &(const struct audioformat) { 2684 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2685 .channels = 2, 2686 .iface = 0, 2687 .altsetting = 1, 2688 .altset_idx = 1, 2689 .attributes = 0, 2690 .endpoint = 0x82, 2691 .ep_idx = 1, 2692 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2693 .datainterval = 1, 2694 .maxpacksize = 0x0126, 2695 .rates = SNDRV_PCM_RATE_44100 | 2696 SNDRV_PCM_RATE_48000, 2697 .rate_min = 44100, 2698 .rate_max = 48000, 2699 .nr_rates = 2, 2700 .rate_table = (unsigned int[]) { 2701 44100, 48000 2702 } 2703 } 2704 }, 2705 { 2706 .ifnum = 1, 2707 .type = QUIRK_MIDI_RAW_BYTES 2708 }, 2709 { 2710 .ifnum = -1 2711 } 2712 } 2713 } 2714 }, 2715 { 2716 USB_DEVICE(0x1235, 0x0018), 2717 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2718 .vendor_name = "Novation", 2719 .product_name = "Twitch", 2720 .ifnum = QUIRK_ANY_INTERFACE, 2721 .type = QUIRK_COMPOSITE, 2722 .data = (const struct snd_usb_audio_quirk[]) { 2723 { 2724 .ifnum = 0, 2725 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2726 .data = & (const struct audioformat) { 2727 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2728 .channels = 4, 2729 .iface = 0, 2730 .altsetting = 1, 2731 .altset_idx = 1, 2732 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2733 .endpoint = 0x01, 2734 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2735 .rates = SNDRV_PCM_RATE_44100 | 2736 SNDRV_PCM_RATE_48000, 2737 .rate_min = 44100, 2738 .rate_max = 48000, 2739 .nr_rates = 2, 2740 .rate_table = (unsigned int[]) { 2741 44100, 48000 2742 } 2743 } 2744 }, 2745 { 2746 .ifnum = 1, 2747 .type = QUIRK_MIDI_RAW_BYTES 2748 }, 2749 { 2750 .ifnum = -1 2751 } 2752 } 2753 } 2754 }, 2755 { 2756 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2757 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2758 .vendor_name = "Novation", 2759 .product_name = "ReMOTE25", 2760 .ifnum = 0, 2761 .type = QUIRK_MIDI_NOVATION 2762 } 2763 }, 2764 2765 /* Access Music devices */ 2766 { 2767 /* VirusTI Desktop */ 2768 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2769 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2770 .ifnum = QUIRK_ANY_INTERFACE, 2771 .type = QUIRK_COMPOSITE, 2772 .data = &(const struct snd_usb_audio_quirk[]) { 2773 { 2774 .ifnum = 3, 2775 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2776 .data = &(const struct snd_usb_midi_endpoint_info) { 2777 .out_cables = 0x0003, 2778 .in_cables = 0x0003 2779 } 2780 }, 2781 { 2782 .ifnum = 4, 2783 .type = QUIRK_IGNORE_INTERFACE 2784 }, 2785 { 2786 .ifnum = -1 2787 } 2788 } 2789 } 2790 }, 2791 2792 /* Native Instruments MK2 series */ 2793 { 2794 /* Komplete Audio 6 */ 2795 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2796 .idVendor = 0x17cc, 2797 .idProduct = 0x1000, 2798 }, 2799 { 2800 /* Traktor Audio 6 */ 2801 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2802 .idVendor = 0x17cc, 2803 .idProduct = 0x1010, 2804 }, 2805 { 2806 /* Traktor Audio 10 */ 2807 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2808 .idVendor = 0x17cc, 2809 .idProduct = 0x1020, 2810 }, 2811 2812 /* QinHeng devices */ 2813 { 2814 USB_DEVICE(0x1a86, 0x752d), 2815 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2816 .vendor_name = "QinHeng", 2817 .product_name = "CH345", 2818 .ifnum = 1, 2819 .type = QUIRK_MIDI_CH345 2820 } 2821 }, 2822 2823 /* KeithMcMillen Stringport */ 2824 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */ 2825 2826 /* Miditech devices */ 2827 { 2828 USB_DEVICE(0x4752, 0x0011), 2829 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2830 .vendor_name = "Miditech", 2831 .product_name = "Midistart-2", 2832 .ifnum = 0, 2833 .type = QUIRK_MIDI_CME 2834 } 2835 }, 2836 2837 /* Central Music devices */ 2838 { 2839 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2840 USB_DEVICE(0x7104, 0x2202), 2841 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2842 .ifnum = 0, 2843 .type = QUIRK_MIDI_CME 2844 } 2845 }, 2846 2847 /* Digidesign Mbox */ 2848 { 2849 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2850 USB_DEVICE(0x0dba, 0x1000), 2851 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2852 .vendor_name = "Digidesign", 2853 .product_name = "MBox", 2854 .ifnum = QUIRK_ANY_INTERFACE, 2855 .type = QUIRK_COMPOSITE, 2856 .data = (const struct snd_usb_audio_quirk[]){ 2857 { 2858 .ifnum = 0, 2859 .type = QUIRK_AUDIO_STANDARD_MIXER, 2860 }, 2861 { 2862 .ifnum = 1, 2863 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2864 .data = &(const struct audioformat) { 2865 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2866 .channels = 2, 2867 .iface = 1, 2868 .altsetting = 1, 2869 .altset_idx = 1, 2870 .attributes = 0x4, 2871 .endpoint = 0x02, 2872 .ep_attr = USB_ENDPOINT_XFER_ISOC | 2873 USB_ENDPOINT_SYNC_SYNC, 2874 .maxpacksize = 0x130, 2875 .rates = SNDRV_PCM_RATE_48000, 2876 .rate_min = 48000, 2877 .rate_max = 48000, 2878 .nr_rates = 1, 2879 .rate_table = (unsigned int[]) { 2880 48000 2881 } 2882 } 2883 }, 2884 { 2885 .ifnum = 1, 2886 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2887 .data = &(const struct audioformat) { 2888 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2889 .channels = 2, 2890 .iface = 1, 2891 .altsetting = 1, 2892 .altset_idx = 1, 2893 .attributes = 0x4, 2894 .endpoint = 0x81, 2895 .ep_idx = 1, 2896 .ep_attr = USB_ENDPOINT_XFER_ISOC | 2897 USB_ENDPOINT_SYNC_ASYNC, 2898 .maxpacksize = 0x130, 2899 .rates = SNDRV_PCM_RATE_48000, 2900 .rate_min = 48000, 2901 .rate_max = 48000, 2902 .nr_rates = 1, 2903 .rate_table = (unsigned int[]) { 2904 48000 2905 } 2906 } 2907 }, 2908 { 2909 .ifnum = -1 2910 } 2911 } 2912 } 2913 }, 2914 2915 /* DIGIDESIGN MBOX 2 */ 2916 { 2917 USB_DEVICE(0x0dba, 0x3000), 2918 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2919 .vendor_name = "Digidesign", 2920 .product_name = "Mbox 2", 2921 .ifnum = QUIRK_ANY_INTERFACE, 2922 .type = QUIRK_COMPOSITE, 2923 .data = (const struct snd_usb_audio_quirk[]) { 2924 { 2925 .ifnum = 0, 2926 .type = QUIRK_IGNORE_INTERFACE 2927 }, 2928 { 2929 .ifnum = 1, 2930 .type = QUIRK_IGNORE_INTERFACE 2931 }, 2932 { 2933 .ifnum = 2, 2934 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2935 .data = &(const struct audioformat) { 2936 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2937 .channels = 2, 2938 .iface = 2, 2939 .altsetting = 2, 2940 .altset_idx = 1, 2941 .attributes = 0x00, 2942 .endpoint = 0x03, 2943 .ep_attr = USB_ENDPOINT_SYNC_ASYNC, 2944 .rates = SNDRV_PCM_RATE_48000, 2945 .rate_min = 48000, 2946 .rate_max = 48000, 2947 .nr_rates = 1, 2948 .rate_table = (unsigned int[]) { 2949 48000 2950 } 2951 } 2952 }, 2953 { 2954 .ifnum = 3, 2955 .type = QUIRK_IGNORE_INTERFACE 2956 }, 2957 { 2958 .ifnum = 4, 2959 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2960 .data = &(const struct audioformat) { 2961 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2962 .channels = 2, 2963 .iface = 4, 2964 .altsetting = 2, 2965 .altset_idx = 1, 2966 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2967 .endpoint = 0x85, 2968 .ep_attr = USB_ENDPOINT_SYNC_SYNC, 2969 .rates = SNDRV_PCM_RATE_48000, 2970 .rate_min = 48000, 2971 .rate_max = 48000, 2972 .nr_rates = 1, 2973 .rate_table = (unsigned int[]) { 2974 48000 2975 } 2976 } 2977 }, 2978 { 2979 .ifnum = 5, 2980 .type = QUIRK_IGNORE_INTERFACE 2981 }, 2982 { 2983 .ifnum = 6, 2984 .type = QUIRK_MIDI_MIDIMAN, 2985 .data = &(const struct snd_usb_midi_endpoint_info) { 2986 .out_ep = 0x02, 2987 .out_cables = 0x0001, 2988 .in_ep = 0x81, 2989 .in_interval = 0x01, 2990 .in_cables = 0x0001 2991 } 2992 }, 2993 { 2994 .ifnum = -1 2995 } 2996 } 2997 } 2998 }, 2999 /* DIGIDESIGN MBOX 3 */ 3000 { 3001 USB_DEVICE(0x0dba, 0x5000), 3002 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3003 .vendor_name = "Digidesign", 3004 .product_name = "Mbox 3", 3005 .ifnum = QUIRK_ANY_INTERFACE, 3006 .type = QUIRK_COMPOSITE, 3007 .data = (const struct snd_usb_audio_quirk[]) { 3008 { 3009 .ifnum = 0, 3010 .type = QUIRK_IGNORE_INTERFACE 3011 }, 3012 { 3013 .ifnum = 1, 3014 .type = QUIRK_IGNORE_INTERFACE 3015 }, 3016 { 3017 .ifnum = 2, 3018 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3019 .data = &(const struct audioformat) { 3020 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3021 .fmt_bits = 24, 3022 .channels = 4, 3023 .iface = 2, 3024 .altsetting = 1, 3025 .altset_idx = 1, 3026 .attributes = 0x00, 3027 .endpoint = USB_RECIP_INTERFACE | USB_DIR_OUT, 3028 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3029 USB_ENDPOINT_SYNC_ASYNC, 3030 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | 3031 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000, 3032 .rate_min = 44100, 3033 .rate_max = 96000, 3034 .nr_rates = 4, 3035 .rate_table = (unsigned int[]) { 3036 44100, 48000, 88200, 96000 3037 }, 3038 .sync_ep = USB_RECIP_INTERFACE | USB_DIR_IN, 3039 .sync_iface = 3, 3040 .sync_altsetting = 1, 3041 .sync_ep_idx = 1, 3042 .implicit_fb = 1, 3043 } 3044 }, 3045 { 3046 .ifnum = 3, 3047 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3048 .data = &(const struct audioformat) { 3049 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3050 .fmt_bits = 24, 3051 .channels = 4, 3052 .iface = 3, 3053 .altsetting = 1, 3054 .altset_idx = 1, 3055 .attributes = 0x00, 3056 .endpoint = USB_RECIP_INTERFACE | USB_DIR_IN, 3057 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3058 USB_ENDPOINT_SYNC_ASYNC, 3059 .maxpacksize = 0x009c, 3060 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | 3061 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000, 3062 .rate_min = 44100, 3063 .rate_max = 96000, 3064 .nr_rates = 4, 3065 .rate_table = (unsigned int[]) { 3066 44100, 48000, 88200, 96000 3067 }, 3068 .implicit_fb = 0, 3069 } 3070 }, 3071 { 3072 .ifnum = 4, 3073 .type = QUIRK_MIDI_FIXED_ENDPOINT, 3074 .data = &(const struct snd_usb_midi_endpoint_info) { 3075 .out_cables = 0x0001, 3076 .in_cables = 0x0001 3077 } 3078 }, 3079 { 3080 .ifnum = -1 3081 } 3082 } 3083 } 3084 }, 3085 { 3086 /* Tascam US122 MKII - playback-only support */ 3087 USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021), 3088 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3089 .vendor_name = "TASCAM", 3090 .product_name = "US122 MKII", 3091 .ifnum = QUIRK_ANY_INTERFACE, 3092 .type = QUIRK_COMPOSITE, 3093 .data = (const struct snd_usb_audio_quirk[]) { 3094 { 3095 .ifnum = 0, 3096 .type = QUIRK_IGNORE_INTERFACE 3097 }, 3098 { 3099 .ifnum = 1, 3100 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3101 .data = &(const struct audioformat) { 3102 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3103 .channels = 2, 3104 .iface = 1, 3105 .altsetting = 1, 3106 .altset_idx = 1, 3107 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3108 .endpoint = 0x02, 3109 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3110 .rates = SNDRV_PCM_RATE_44100 | 3111 SNDRV_PCM_RATE_48000 | 3112 SNDRV_PCM_RATE_88200 | 3113 SNDRV_PCM_RATE_96000, 3114 .rate_min = 44100, 3115 .rate_max = 96000, 3116 .nr_rates = 4, 3117 .rate_table = (unsigned int[]) { 3118 44100, 48000, 88200, 96000 3119 } 3120 } 3121 }, 3122 { 3123 .ifnum = -1 3124 } 3125 } 3126 } 3127 }, 3128 3129 /* Denon DN-X1600 */ 3130 { 3131 USB_AUDIO_DEVICE(0x154e, 0x500e), 3132 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3133 .vendor_name = "Denon", 3134 .product_name = "DN-X1600", 3135 .ifnum = QUIRK_ANY_INTERFACE, 3136 .type = QUIRK_COMPOSITE, 3137 .data = (const struct snd_usb_audio_quirk[]){ 3138 { 3139 .ifnum = 0, 3140 .type = QUIRK_IGNORE_INTERFACE, 3141 }, 3142 { 3143 .ifnum = 1, 3144 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3145 .data = &(const struct audioformat) { 3146 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3147 .channels = 8, 3148 .iface = 1, 3149 .altsetting = 1, 3150 .altset_idx = 1, 3151 .attributes = 0x0, 3152 .endpoint = 0x01, 3153 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3154 USB_ENDPOINT_SYNC_ADAPTIVE, 3155 .maxpacksize = 0x138, 3156 .rates = SNDRV_PCM_RATE_48000, 3157 .rate_min = 48000, 3158 .rate_max = 48000, 3159 .nr_rates = 1, 3160 .rate_table = (unsigned int[]) { 3161 48000 3162 } 3163 } 3164 }, 3165 { 3166 .ifnum = 2, 3167 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3168 .data = &(const struct audioformat) { 3169 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3170 .channels = 8, 3171 .iface = 2, 3172 .altsetting = 1, 3173 .altset_idx = 1, 3174 .attributes = 0x0, 3175 .endpoint = 0x85, 3176 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3177 USB_ENDPOINT_SYNC_ADAPTIVE, 3178 .maxpacksize = 0x138, 3179 .rates = SNDRV_PCM_RATE_48000, 3180 .rate_min = 48000, 3181 .rate_max = 48000, 3182 .nr_rates = 1, 3183 .rate_table = (unsigned int[]) { 3184 48000 3185 } 3186 } 3187 }, 3188 { 3189 .ifnum = 4, 3190 .type = QUIRK_MIDI_STANDARD_INTERFACE, 3191 }, 3192 { 3193 .ifnum = -1 3194 } 3195 } 3196 } 3197 }, 3198 3199 /* Microsoft XboxLive Headset/Xbox Communicator */ 3200 { 3201 USB_DEVICE(0x045e, 0x0283), 3202 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3203 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3204 .vendor_name = "Microsoft", 3205 .product_name = "XboxLive Headset/Xbox Communicator", 3206 .ifnum = QUIRK_ANY_INTERFACE, 3207 .type = QUIRK_COMPOSITE, 3208 .data = &(const struct snd_usb_audio_quirk[]) { 3209 { 3210 /* playback */ 3211 .ifnum = 0, 3212 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3213 .data = &(const struct audioformat) { 3214 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3215 .channels = 1, 3216 .iface = 0, 3217 .altsetting = 0, 3218 .altset_idx = 0, 3219 .attributes = 0, 3220 .endpoint = 0x04, 3221 .ep_attr = 0x05, 3222 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3223 .rate_min = 22050, 3224 .rate_max = 22050 3225 } 3226 }, 3227 { 3228 /* capture */ 3229 .ifnum = 1, 3230 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3231 .data = &(const struct audioformat) { 3232 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3233 .channels = 1, 3234 .iface = 1, 3235 .altsetting = 0, 3236 .altset_idx = 0, 3237 .attributes = 0, 3238 .endpoint = 0x85, 3239 .ep_attr = 0x05, 3240 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3241 .rate_min = 16000, 3242 .rate_max = 16000 3243 } 3244 }, 3245 { 3246 .ifnum = -1 3247 } 3248 } 3249 } 3250 }, 3251 3252 /* Reloop Play */ 3253 { 3254 USB_DEVICE(0x200c, 0x100b), 3255 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3256 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3257 .ifnum = QUIRK_ANY_INTERFACE, 3258 .type = QUIRK_COMPOSITE, 3259 .data = &(const struct snd_usb_audio_quirk[]) { 3260 { 3261 .ifnum = 0, 3262 .type = QUIRK_AUDIO_STANDARD_MIXER, 3263 }, 3264 { 3265 .ifnum = 1, 3266 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3267 .data = &(const struct audioformat) { 3268 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3269 .channels = 4, 3270 .iface = 1, 3271 .altsetting = 1, 3272 .altset_idx = 1, 3273 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3274 .endpoint = 0x01, 3275 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE, 3276 .rates = SNDRV_PCM_RATE_44100 | 3277 SNDRV_PCM_RATE_48000, 3278 .rate_min = 44100, 3279 .rate_max = 48000, 3280 .nr_rates = 2, 3281 .rate_table = (unsigned int[]) { 3282 44100, 48000 3283 } 3284 } 3285 }, 3286 { 3287 .ifnum = -1 3288 } 3289 } 3290 } 3291 }, 3292 3293 { 3294 /* 3295 * ZOOM R16/24 in audio interface mode. 3296 * Playback requires an extra four byte LE length indicator 3297 * at the start of each isochronous packet. This quirk is 3298 * enabled in create_standard_audio_quirk(). 3299 */ 3300 USB_DEVICE(0x1686, 0x00dd), 3301 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3302 .ifnum = QUIRK_ANY_INTERFACE, 3303 .type = QUIRK_COMPOSITE, 3304 .data = (const struct snd_usb_audio_quirk[]) { 3305 { 3306 /* Playback */ 3307 .ifnum = 1, 3308 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 3309 }, 3310 { 3311 /* Capture */ 3312 .ifnum = 2, 3313 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 3314 }, 3315 { 3316 /* Midi */ 3317 .ifnum = 3, 3318 .type = QUIRK_MIDI_STANDARD_INTERFACE 3319 }, 3320 { 3321 .ifnum = -1 3322 }, 3323 } 3324 } 3325 }, 3326 3327 { 3328 /* 3329 * Some USB MIDI devices don't have an audio control interface, 3330 * so we have to grab MIDI streaming interfaces here. 3331 */ 3332 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 3333 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 3334 .bInterfaceClass = USB_CLASS_AUDIO, 3335 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 3336 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3337 .ifnum = QUIRK_ANY_INTERFACE, 3338 .type = QUIRK_MIDI_STANDARD_INTERFACE 3339 } 3340 }, 3341 3342 /* Rane SL-1 */ 3343 { 3344 USB_DEVICE(0x13e5, 0x0001), 3345 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3346 .ifnum = QUIRK_ANY_INTERFACE, 3347 .type = QUIRK_AUDIO_STANDARD_INTERFACE 3348 } 3349 }, 3350 3351 /* disabled due to regression for other devices; 3352 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905 3353 */ 3354 #if 0 3355 { 3356 /* 3357 * Nura's first gen headphones use Cambridge Silicon Radio's vendor 3358 * ID, but it looks like the product ID actually is only for Nura. 3359 * The capture interface does not work at all (even on Windows), 3360 * and only the 48 kHz sample rate works for the playback interface. 3361 */ 3362 USB_DEVICE(0x0a12, 0x1243), 3363 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3364 .ifnum = QUIRK_ANY_INTERFACE, 3365 .type = QUIRK_COMPOSITE, 3366 .data = (const struct snd_usb_audio_quirk[]) { 3367 { 3368 .ifnum = 0, 3369 .type = QUIRK_AUDIO_STANDARD_MIXER, 3370 }, 3371 /* Capture */ 3372 { 3373 .ifnum = 1, 3374 .type = QUIRK_IGNORE_INTERFACE, 3375 }, 3376 /* Playback */ 3377 { 3378 .ifnum = 2, 3379 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3380 .data = &(const struct audioformat) { 3381 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3382 .channels = 2, 3383 .iface = 2, 3384 .altsetting = 1, 3385 .altset_idx = 1, 3386 .attributes = UAC_EP_CS_ATTR_FILL_MAX | 3387 UAC_EP_CS_ATTR_SAMPLE_RATE, 3388 .endpoint = 0x03, 3389 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3390 .rates = SNDRV_PCM_RATE_48000, 3391 .rate_min = 48000, 3392 .rate_max = 48000, 3393 .nr_rates = 1, 3394 .rate_table = (unsigned int[]) { 3395 48000 3396 } 3397 } 3398 }, 3399 { 3400 .ifnum = -1 3401 }, 3402 } 3403 } 3404 }, 3405 #endif /* disabled */ 3406 3407 { 3408 /* 3409 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate 3410 * even though it advertises more. The capture interface doesn't work 3411 * even on windows. 3412 */ 3413 USB_DEVICE(0x19b5, 0x0021), 3414 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3415 .ifnum = QUIRK_ANY_INTERFACE, 3416 .type = QUIRK_COMPOSITE, 3417 .data = (const struct snd_usb_audio_quirk[]) { 3418 { 3419 .ifnum = 0, 3420 .type = QUIRK_AUDIO_STANDARD_MIXER, 3421 }, 3422 /* Playback */ 3423 { 3424 .ifnum = 1, 3425 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3426 .data = &(const struct audioformat) { 3427 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3428 .channels = 2, 3429 .iface = 1, 3430 .altsetting = 1, 3431 .altset_idx = 1, 3432 .attributes = UAC_EP_CS_ATTR_FILL_MAX | 3433 UAC_EP_CS_ATTR_SAMPLE_RATE, 3434 .endpoint = 0x03, 3435 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3436 .rates = SNDRV_PCM_RATE_48000, 3437 .rate_min = 48000, 3438 .rate_max = 48000, 3439 .nr_rates = 1, 3440 .rate_table = (unsigned int[]) { 3441 48000 3442 } 3443 } 3444 }, 3445 { 3446 .ifnum = -1 3447 }, 3448 } 3449 } 3450 }, 3451 /* MOTU Microbook II */ 3452 { 3453 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004), 3454 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3455 .vendor_name = "MOTU", 3456 .product_name = "MicroBookII", 3457 .ifnum = QUIRK_ANY_INTERFACE, 3458 .type = QUIRK_COMPOSITE, 3459 .data = (const struct snd_usb_audio_quirk[]) { 3460 { 3461 .ifnum = 0, 3462 .type = QUIRK_AUDIO_STANDARD_MIXER, 3463 }, 3464 { 3465 .ifnum = 0, 3466 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3467 .data = &(const struct audioformat) { 3468 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3469 .channels = 6, 3470 .iface = 0, 3471 .altsetting = 1, 3472 .altset_idx = 1, 3473 .attributes = 0, 3474 .endpoint = 0x84, 3475 .rates = SNDRV_PCM_RATE_96000, 3476 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3477 USB_ENDPOINT_SYNC_ASYNC, 3478 .rate_min = 96000, 3479 .rate_max = 96000, 3480 .nr_rates = 1, 3481 .maxpacksize = 0x00d8, 3482 .rate_table = (unsigned int[]) { 3483 96000 3484 } 3485 } 3486 }, 3487 { 3488 .ifnum = 0, 3489 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3490 .data = &(const struct audioformat) { 3491 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3492 .channels = 8, 3493 .iface = 0, 3494 .altsetting = 1, 3495 .altset_idx = 1, 3496 .attributes = 0, 3497 .endpoint = 0x03, 3498 .ep_idx = 1, 3499 .rates = SNDRV_PCM_RATE_96000, 3500 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3501 USB_ENDPOINT_SYNC_ASYNC, 3502 .rate_min = 96000, 3503 .rate_max = 96000, 3504 .nr_rates = 1, 3505 .maxpacksize = 0x0120, 3506 .rate_table = (unsigned int[]) { 3507 96000 3508 } 3509 } 3510 }, 3511 { 3512 .ifnum = -1 3513 } 3514 } 3515 } 3516 }, 3517 { 3518 /* 3519 * PIONEER DJ DDJ-SX3 3520 * PCM is 12 channels out, 10 channels in @ 44.1 fixed 3521 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86 3522 * The feedback for the output is the input. 3523 */ 3524 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023), 3525 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3526 .ifnum = QUIRK_ANY_INTERFACE, 3527 .type = QUIRK_COMPOSITE, 3528 .data = (const struct snd_usb_audio_quirk[]) { 3529 { 3530 .ifnum = 0, 3531 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3532 .data = &(const struct audioformat) { 3533 .formats = SNDRV_PCM_FMTBIT_S32_LE, 3534 .channels = 12, 3535 .iface = 0, 3536 .altsetting = 1, 3537 .altset_idx = 1, 3538 .endpoint = 0x05, 3539 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3540 USB_ENDPOINT_SYNC_ASYNC, 3541 .rates = SNDRV_PCM_RATE_44100, 3542 .rate_min = 44100, 3543 .rate_max = 44100, 3544 .nr_rates = 1, 3545 .rate_table = (unsigned int[]) { 44100 } 3546 } 3547 }, 3548 { 3549 .ifnum = 0, 3550 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3551 .data = &(const struct audioformat) { 3552 .formats = SNDRV_PCM_FMTBIT_S32_LE, 3553 .channels = 10, 3554 .iface = 0, 3555 .altsetting = 1, 3556 .altset_idx = 1, 3557 .endpoint = 0x86, 3558 .ep_idx = 1, 3559 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3560 USB_ENDPOINT_SYNC_ASYNC| 3561 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3562 .rates = SNDRV_PCM_RATE_44100, 3563 .rate_min = 44100, 3564 .rate_max = 44100, 3565 .nr_rates = 1, 3566 .rate_table = (unsigned int[]) { 44100 } 3567 } 3568 }, 3569 { 3570 .ifnum = -1 3571 } 3572 } 3573 } 3574 }, 3575 { 3576 /* 3577 * Pioneer DJ DJM-250MK2 3578 * PCM is 8 channels out @ 48 fixed (endpoint 0x01) 3579 * and 8 channels in @ 48 fixed (endpoint 0x82). 3580 * 3581 * Both playback and recording is working, even simultaneously. 3582 * 3583 * Playback channels could be mapped to: 3584 * - CH1 3585 * - CH2 3586 * - AUX 3587 * 3588 * Recording channels could be mapped to: 3589 * - Post CH1 Fader 3590 * - Post CH2 Fader 3591 * - Cross Fader A 3592 * - Cross Fader B 3593 * - MIC 3594 * - AUX 3595 * - REC OUT 3596 * 3597 * There is remaining problem with recording directly from PHONO/LINE. 3598 * If we map a channel to: 3599 * - CH1 Control Tone PHONO 3600 * - CH1 Control Tone LINE 3601 * - CH2 Control Tone PHONO 3602 * - CH2 Control Tone LINE 3603 * it is silent. 3604 * There is no signal even on other operating systems with official drivers. 3605 * The signal appears only when a supported application is started. 3606 * This needs to be investigated yet... 3607 * (there is quite a lot communication on the USB in both directions) 3608 * 3609 * In current version this mixer could be used for playback 3610 * and for recording from vinyls (through Post CH* Fader) 3611 * but not for DVS (Digital Vinyl Systems) like in Mixxx. 3612 */ 3613 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017), 3614 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3615 .ifnum = QUIRK_ANY_INTERFACE, 3616 .type = QUIRK_COMPOSITE, 3617 .data = (const struct snd_usb_audio_quirk[]) { 3618 { 3619 .ifnum = 0, 3620 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3621 .data = &(const struct audioformat) { 3622 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3623 .channels = 8, // outputs 3624 .iface = 0, 3625 .altsetting = 1, 3626 .altset_idx = 1, 3627 .endpoint = 0x01, 3628 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3629 USB_ENDPOINT_SYNC_ASYNC, 3630 .rates = SNDRV_PCM_RATE_48000, 3631 .rate_min = 48000, 3632 .rate_max = 48000, 3633 .nr_rates = 1, 3634 .rate_table = (unsigned int[]) { 48000 } 3635 } 3636 }, 3637 { 3638 .ifnum = 0, 3639 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3640 .data = &(const struct audioformat) { 3641 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3642 .channels = 8, // inputs 3643 .iface = 0, 3644 .altsetting = 1, 3645 .altset_idx = 1, 3646 .endpoint = 0x82, 3647 .ep_idx = 1, 3648 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3649 USB_ENDPOINT_SYNC_ASYNC| 3650 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3651 .rates = SNDRV_PCM_RATE_48000, 3652 .rate_min = 48000, 3653 .rate_max = 48000, 3654 .nr_rates = 1, 3655 .rate_table = (unsigned int[]) { 48000 } 3656 } 3657 }, 3658 { 3659 .ifnum = -1 3660 } 3661 } 3662 } 3663 }, 3664 { 3665 /* 3666 * PIONEER DJ DDJ-RB 3667 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed 3668 * The feedback for the output is the dummy input. 3669 */ 3670 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e), 3671 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3672 .ifnum = QUIRK_ANY_INTERFACE, 3673 .type = QUIRK_COMPOSITE, 3674 .data = (const struct snd_usb_audio_quirk[]) { 3675 { 3676 .ifnum = 0, 3677 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3678 .data = &(const struct audioformat) { 3679 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3680 .channels = 4, 3681 .iface = 0, 3682 .altsetting = 1, 3683 .altset_idx = 1, 3684 .endpoint = 0x01, 3685 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3686 USB_ENDPOINT_SYNC_ASYNC, 3687 .rates = SNDRV_PCM_RATE_44100, 3688 .rate_min = 44100, 3689 .rate_max = 44100, 3690 .nr_rates = 1, 3691 .rate_table = (unsigned int[]) { 44100 } 3692 } 3693 }, 3694 { 3695 .ifnum = 0, 3696 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3697 .data = &(const struct audioformat) { 3698 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3699 .channels = 2, 3700 .iface = 0, 3701 .altsetting = 1, 3702 .altset_idx = 1, 3703 .endpoint = 0x82, 3704 .ep_idx = 1, 3705 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3706 USB_ENDPOINT_SYNC_ASYNC| 3707 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3708 .rates = SNDRV_PCM_RATE_44100, 3709 .rate_min = 44100, 3710 .rate_max = 44100, 3711 .nr_rates = 1, 3712 .rate_table = (unsigned int[]) { 44100 } 3713 } 3714 }, 3715 { 3716 .ifnum = -1 3717 } 3718 } 3719 } 3720 }, 3721 3722 { 3723 /* 3724 * PIONEER DJ DDJ-RR 3725 * PCM is 6 channels out & 4 channels in @ 44.1 fixed 3726 */ 3727 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000d), 3728 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3729 .ifnum = QUIRK_ANY_INTERFACE, 3730 .type = QUIRK_COMPOSITE, 3731 .data = (const struct snd_usb_audio_quirk[]) { 3732 { 3733 .ifnum = 0, 3734 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3735 .data = &(const struct audioformat) { 3736 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3737 .channels = 6, //Master, Headphones & Booth 3738 .iface = 0, 3739 .altsetting = 1, 3740 .altset_idx = 1, 3741 .endpoint = 0x01, 3742 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3743 USB_ENDPOINT_SYNC_ASYNC, 3744 .rates = SNDRV_PCM_RATE_44100, 3745 .rate_min = 44100, 3746 .rate_max = 44100, 3747 .nr_rates = 1, 3748 .rate_table = (unsigned int[]) { 44100 } 3749 } 3750 }, 3751 { 3752 .ifnum = 0, 3753 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3754 .data = &(const struct audioformat) { 3755 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3756 .channels = 4, //2x RCA inputs (CH1 & CH2) 3757 .iface = 0, 3758 .altsetting = 1, 3759 .altset_idx = 1, 3760 .endpoint = 0x82, 3761 .ep_idx = 1, 3762 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3763 USB_ENDPOINT_SYNC_ASYNC| 3764 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3765 .rates = SNDRV_PCM_RATE_44100, 3766 .rate_min = 44100, 3767 .rate_max = 44100, 3768 .nr_rates = 1, 3769 .rate_table = (unsigned int[]) { 44100 } 3770 } 3771 }, 3772 { 3773 .ifnum = -1 3774 } 3775 } 3776 } 3777 }, 3778 3779 { 3780 /* 3781 * PIONEER DJ DDJ-SR2 3782 * PCM is 4 channels out, 6 channels in @ 44.1 fixed 3783 * The Feedback for the output is the input 3784 */ 3785 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001e), 3786 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3787 .ifnum = QUIRK_ANY_INTERFACE, 3788 .type = QUIRK_COMPOSITE, 3789 .data = (const struct snd_usb_audio_quirk[]) { 3790 { 3791 .ifnum = 0, 3792 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3793 .data = &(const struct audioformat) { 3794 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3795 .channels = 4, 3796 .iface = 0, 3797 .altsetting = 1, 3798 .altset_idx = 1, 3799 .endpoint = 0x01, 3800 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3801 USB_ENDPOINT_SYNC_ASYNC, 3802 .rates = SNDRV_PCM_RATE_44100, 3803 .rate_min = 44100, 3804 .rate_max = 44100, 3805 .nr_rates = 1, 3806 .rate_table = (unsigned int[]) { 44100 } 3807 } 3808 }, 3809 { 3810 .ifnum = 0, 3811 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3812 .data = &(const struct audioformat) { 3813 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3814 .channels = 6, 3815 .iface = 0, 3816 .altsetting = 1, 3817 .altset_idx = 1, 3818 .endpoint = 0x82, 3819 .ep_idx = 1, 3820 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3821 USB_ENDPOINT_SYNC_ASYNC| 3822 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3823 .rates = SNDRV_PCM_RATE_44100, 3824 .rate_min = 44100, 3825 .rate_max = 44100, 3826 .nr_rates = 1, 3827 .rate_table = (unsigned int[]) { 44100 } 3828 } 3829 }, 3830 { 3831 .ifnum = -1 3832 } 3833 } 3834 } 3835 }, 3836 3837 { 3838 /* 3839 * Pioneer DJ DJM-900NXS2 3840 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE 3841 */ 3842 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a), 3843 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3844 .ifnum = QUIRK_ANY_INTERFACE, 3845 .type = QUIRK_COMPOSITE, 3846 .data = (const struct snd_usb_audio_quirk[]) { 3847 { 3848 .ifnum = 0, 3849 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3850 .data = &(const struct audioformat) { 3851 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3852 .channels = 10, 3853 .iface = 0, 3854 .altsetting = 1, 3855 .altset_idx = 1, 3856 .endpoint = 0x01, 3857 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3858 USB_ENDPOINT_SYNC_ASYNC, 3859 .rates = SNDRV_PCM_RATE_44100| 3860 SNDRV_PCM_RATE_48000| 3861 SNDRV_PCM_RATE_96000, 3862 .rate_min = 44100, 3863 .rate_max = 96000, 3864 .nr_rates = 3, 3865 .rate_table = (unsigned int[]) { 3866 44100, 48000, 96000 3867 } 3868 } 3869 }, 3870 { 3871 .ifnum = 0, 3872 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3873 .data = &(const struct audioformat) { 3874 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3875 .channels = 12, 3876 .iface = 0, 3877 .altsetting = 1, 3878 .altset_idx = 1, 3879 .endpoint = 0x82, 3880 .ep_idx = 1, 3881 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3882 USB_ENDPOINT_SYNC_ASYNC| 3883 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3884 .rates = SNDRV_PCM_RATE_44100| 3885 SNDRV_PCM_RATE_48000| 3886 SNDRV_PCM_RATE_96000, 3887 .rate_min = 44100, 3888 .rate_max = 96000, 3889 .nr_rates = 3, 3890 .rate_table = (unsigned int[]) { 3891 44100, 48000, 96000 3892 } 3893 } 3894 }, 3895 { 3896 .ifnum = -1 3897 } 3898 } 3899 } 3900 }, 3901 3902 { 3903 /* 3904 * PIONEER DJ DDJ-800 3905 * PCM is 6 channels out, 6 channels in @ 44.1 fixed 3906 * The Feedback for the output is the input 3907 */ 3908 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0029), 3909 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3910 .ifnum = QUIRK_ANY_INTERFACE, 3911 .type = QUIRK_COMPOSITE, 3912 .data = (const struct snd_usb_audio_quirk[]) { 3913 { 3914 .ifnum = 0, 3915 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3916 .data = &(const struct audioformat) { 3917 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3918 .channels = 6, 3919 .iface = 0, 3920 .altsetting = 1, 3921 .altset_idx = 1, 3922 .endpoint = 0x01, 3923 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3924 USB_ENDPOINT_SYNC_ASYNC, 3925 .rates = SNDRV_PCM_RATE_44100, 3926 .rate_min = 44100, 3927 .rate_max = 44100, 3928 .nr_rates = 1, 3929 .rate_table = (unsigned int[]) { 44100 } 3930 } 3931 }, 3932 { 3933 .ifnum = 0, 3934 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3935 .data = &(const struct audioformat) { 3936 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3937 .channels = 6, 3938 .iface = 0, 3939 .altsetting = 1, 3940 .altset_idx = 1, 3941 .endpoint = 0x82, 3942 .ep_idx = 1, 3943 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3944 USB_ENDPOINT_SYNC_ASYNC| 3945 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3946 .rates = SNDRV_PCM_RATE_44100, 3947 .rate_min = 44100, 3948 .rate_max = 44100, 3949 .nr_rates = 1, 3950 .rate_table = (unsigned int[]) { 44100 } 3951 } 3952 }, 3953 { 3954 .ifnum = -1 3955 } 3956 } 3957 } 3958 }, 3959 3960 /* 3961 * MacroSilicon MS2100/MS2106 based AV capture cards 3962 * 3963 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch. 3964 * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if 3965 * they pretend to be 96kHz mono as a workaround for stereo being broken 3966 * by that... 3967 * 3968 * They also have an issue with initial stream alignment that causes the 3969 * channels to be swapped and out of phase, which is dealt with in quirks.c. 3970 */ 3971 { 3972 USB_AUDIO_DEVICE(0x534d, 0x0021), 3973 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3974 .vendor_name = "MacroSilicon", 3975 .product_name = "MS210x", 3976 .ifnum = QUIRK_ANY_INTERFACE, 3977 .type = QUIRK_COMPOSITE, 3978 .data = &(const struct snd_usb_audio_quirk[]) { 3979 { 3980 .ifnum = 2, 3981 .type = QUIRK_AUDIO_STANDARD_MIXER, 3982 }, 3983 { 3984 .ifnum = 3, 3985 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3986 .data = &(const struct audioformat) { 3987 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3988 .channels = 2, 3989 .iface = 3, 3990 .altsetting = 1, 3991 .altset_idx = 1, 3992 .attributes = 0, 3993 .endpoint = 0x82, 3994 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3995 USB_ENDPOINT_SYNC_ASYNC, 3996 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3997 .rate_min = 48000, 3998 .rate_max = 48000, 3999 } 4000 }, 4001 { 4002 .ifnum = -1 4003 } 4004 } 4005 } 4006 }, 4007 4008 /* 4009 * MacroSilicon MS2109 based HDMI capture cards 4010 * 4011 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch. 4012 * They also need QUIRK_FLAG_ALIGN_TRANSFER, which makes one wonder if 4013 * they pretend to be 96kHz mono as a workaround for stereo being broken 4014 * by that... 4015 * 4016 * They also have an issue with initial stream alignment that causes the 4017 * channels to be swapped and out of phase, which is dealt with in quirks.c. 4018 */ 4019 { 4020 USB_AUDIO_DEVICE(0x534d, 0x2109), 4021 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4022 .vendor_name = "MacroSilicon", 4023 .product_name = "MS2109", 4024 .ifnum = QUIRK_ANY_INTERFACE, 4025 .type = QUIRK_COMPOSITE, 4026 .data = &(const struct snd_usb_audio_quirk[]) { 4027 { 4028 .ifnum = 2, 4029 .type = QUIRK_AUDIO_STANDARD_MIXER, 4030 }, 4031 { 4032 .ifnum = 3, 4033 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4034 .data = &(const struct audioformat) { 4035 .formats = SNDRV_PCM_FMTBIT_S16_LE, 4036 .channels = 2, 4037 .iface = 3, 4038 .altsetting = 1, 4039 .altset_idx = 1, 4040 .attributes = 0, 4041 .endpoint = 0x82, 4042 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4043 USB_ENDPOINT_SYNC_ASYNC, 4044 .rates = SNDRV_PCM_RATE_CONTINUOUS, 4045 .rate_min = 48000, 4046 .rate_max = 48000, 4047 } 4048 }, 4049 { 4050 .ifnum = -1 4051 } 4052 } 4053 } 4054 }, 4055 { 4056 /* 4057 * Pioneer DJ DJM-750 4058 * 8 channels playback & 8 channels capture @ 44.1/48/96kHz S24LE 4059 */ 4060 USB_DEVICE_VENDOR_SPEC(0x08e4, 0x017f), 4061 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4062 .ifnum = QUIRK_ANY_INTERFACE, 4063 .type = QUIRK_COMPOSITE, 4064 .data = (const struct snd_usb_audio_quirk[]) { 4065 { 4066 .ifnum = 0, 4067 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4068 .data = &(const struct audioformat) { 4069 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4070 .channels = 8, 4071 .iface = 0, 4072 .altsetting = 1, 4073 .altset_idx = 1, 4074 .endpoint = 0x05, 4075 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4076 USB_ENDPOINT_SYNC_ASYNC, 4077 .rates = SNDRV_PCM_RATE_44100| 4078 SNDRV_PCM_RATE_48000| 4079 SNDRV_PCM_RATE_96000, 4080 .rate_min = 44100, 4081 .rate_max = 96000, 4082 .nr_rates = 3, 4083 .rate_table = (unsigned int[]) { 44100, 48000, 96000 } 4084 } 4085 }, 4086 { 4087 .ifnum = 0, 4088 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4089 .data = &(const struct audioformat) { 4090 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4091 .channels = 8, 4092 .iface = 0, 4093 .altsetting = 1, 4094 .altset_idx = 1, 4095 .endpoint = 0x86, 4096 .ep_idx = 1, 4097 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4098 USB_ENDPOINT_SYNC_ASYNC| 4099 USB_ENDPOINT_USAGE_IMPLICIT_FB, 4100 .rates = SNDRV_PCM_RATE_44100| 4101 SNDRV_PCM_RATE_48000| 4102 SNDRV_PCM_RATE_96000, 4103 .rate_min = 44100, 4104 .rate_max = 96000, 4105 .nr_rates = 3, 4106 .rate_table = (unsigned int[]) { 44100, 48000, 96000 } 4107 } 4108 }, 4109 { 4110 .ifnum = -1 4111 } 4112 } 4113 } 4114 }, 4115 { 4116 /* 4117 * Pioneer DJ DJM-750MK2 4118 * 10 channels playback & 12 channels capture @ 48kHz S24LE 4119 */ 4120 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x001b), 4121 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4122 .ifnum = QUIRK_ANY_INTERFACE, 4123 .type = QUIRK_COMPOSITE, 4124 .data = (const struct snd_usb_audio_quirk[]) { 4125 { 4126 .ifnum = 0, 4127 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4128 .data = &(const struct audioformat) { 4129 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4130 .channels = 10, 4131 .iface = 0, 4132 .altsetting = 1, 4133 .altset_idx = 1, 4134 .endpoint = 0x01, 4135 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4136 USB_ENDPOINT_SYNC_ASYNC, 4137 .rates = SNDRV_PCM_RATE_48000, 4138 .rate_min = 48000, 4139 .rate_max = 48000, 4140 .nr_rates = 1, 4141 .rate_table = (unsigned int[]) { 4142 48000 4143 } 4144 } 4145 }, 4146 { 4147 .ifnum = 0, 4148 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4149 .data = &(const struct audioformat) { 4150 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4151 .channels = 12, 4152 .iface = 0, 4153 .altsetting = 1, 4154 .altset_idx = 1, 4155 .endpoint = 0x82, 4156 .ep_idx = 1, 4157 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4158 USB_ENDPOINT_SYNC_ASYNC| 4159 USB_ENDPOINT_USAGE_IMPLICIT_FB, 4160 .rates = SNDRV_PCM_RATE_48000, 4161 .rate_min = 48000, 4162 .rate_max = 48000, 4163 .nr_rates = 1, 4164 .rate_table = (unsigned int[]) { 48000 } 4165 } 4166 }, 4167 { 4168 .ifnum = -1 4169 } 4170 } 4171 } 4172 }, 4173 { 4174 /* 4175 * Pioneer DJ DJM-850 4176 * 8 channels playback and 8 channels capture @ 44.1/48/96kHz S24LE 4177 * Playback on EP 0x05 4178 * Capture on EP 0x86 4179 */ 4180 USB_DEVICE_VENDOR_SPEC(0x08e4, 0x0163), 4181 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4182 .ifnum = QUIRK_ANY_INTERFACE, 4183 .type = QUIRK_COMPOSITE, 4184 .data = (const struct snd_usb_audio_quirk[]) { 4185 { 4186 .ifnum = 0, 4187 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4188 .data = &(const struct audioformat) { 4189 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4190 .channels = 8, 4191 .iface = 0, 4192 .altsetting = 1, 4193 .altset_idx = 1, 4194 .endpoint = 0x05, 4195 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4196 USB_ENDPOINT_SYNC_ASYNC| 4197 USB_ENDPOINT_USAGE_DATA, 4198 .rates = SNDRV_PCM_RATE_44100| 4199 SNDRV_PCM_RATE_48000| 4200 SNDRV_PCM_RATE_96000, 4201 .rate_min = 44100, 4202 .rate_max = 96000, 4203 .nr_rates = 3, 4204 .rate_table = (unsigned int[]) { 44100, 48000, 96000 } 4205 } 4206 }, 4207 { 4208 .ifnum = 0, 4209 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4210 .data = &(const struct audioformat) { 4211 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4212 .channels = 8, 4213 .iface = 0, 4214 .altsetting = 1, 4215 .altset_idx = 1, 4216 .endpoint = 0x86, 4217 .ep_idx = 1, 4218 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4219 USB_ENDPOINT_SYNC_ASYNC| 4220 USB_ENDPOINT_USAGE_DATA, 4221 .rates = SNDRV_PCM_RATE_44100| 4222 SNDRV_PCM_RATE_48000| 4223 SNDRV_PCM_RATE_96000, 4224 .rate_min = 44100, 4225 .rate_max = 96000, 4226 .nr_rates = 3, 4227 .rate_table = (unsigned int[]) { 44100, 48000, 96000 } 4228 } 4229 }, 4230 { 4231 .ifnum = -1 4232 } 4233 } 4234 } 4235 }, 4236 { 4237 /* 4238 * Pioneer DJ DJM-450 4239 * PCM is 8 channels out @ 48 fixed (endpoint 0x01) 4240 * and 8 channels in @ 48 fixed (endpoint 0x82). 4241 */ 4242 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0013), 4243 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4244 .ifnum = QUIRK_ANY_INTERFACE, 4245 .type = QUIRK_COMPOSITE, 4246 .data = (const struct snd_usb_audio_quirk[]) { 4247 { 4248 .ifnum = 0, 4249 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4250 .data = &(const struct audioformat) { 4251 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4252 .channels = 8, // outputs 4253 .iface = 0, 4254 .altsetting = 1, 4255 .altset_idx = 1, 4256 .endpoint = 0x01, 4257 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4258 USB_ENDPOINT_SYNC_ASYNC, 4259 .rates = SNDRV_PCM_RATE_48000, 4260 .rate_min = 48000, 4261 .rate_max = 48000, 4262 .nr_rates = 1, 4263 .rate_table = (unsigned int[]) { 48000 } 4264 } 4265 }, 4266 { 4267 .ifnum = 0, 4268 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4269 .data = &(const struct audioformat) { 4270 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 4271 .channels = 8, // inputs 4272 .iface = 0, 4273 .altsetting = 1, 4274 .altset_idx = 1, 4275 .endpoint = 0x82, 4276 .ep_idx = 1, 4277 .ep_attr = USB_ENDPOINT_XFER_ISOC| 4278 USB_ENDPOINT_SYNC_ASYNC| 4279 USB_ENDPOINT_USAGE_IMPLICIT_FB, 4280 .rates = SNDRV_PCM_RATE_48000, 4281 .rate_min = 48000, 4282 .rate_max = 48000, 4283 .nr_rates = 1, 4284 .rate_table = (unsigned int[]) { 48000 } 4285 } 4286 }, 4287 { 4288 .ifnum = -1 4289 } 4290 } 4291 } 4292 }, 4293 { 4294 /* 4295 * Sennheiser GSP670 4296 * Change order of interfaces loaded 4297 */ 4298 USB_DEVICE(0x1395, 0x0300), 4299 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 4300 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4301 .ifnum = QUIRK_ANY_INTERFACE, 4302 .type = QUIRK_COMPOSITE, 4303 .data = &(const struct snd_usb_audio_quirk[]) { 4304 // Communication 4305 { 4306 .ifnum = 3, 4307 .type = QUIRK_AUDIO_STANDARD_INTERFACE 4308 }, 4309 // Recording 4310 { 4311 .ifnum = 4, 4312 .type = QUIRK_AUDIO_STANDARD_INTERFACE 4313 }, 4314 // Main 4315 { 4316 .ifnum = 1, 4317 .type = QUIRK_AUDIO_STANDARD_INTERFACE 4318 }, 4319 { 4320 .ifnum = -1 4321 } 4322 } 4323 } 4324 }, 4325 { 4326 /* 4327 * Fiero SC-01 (firmware v1.0.0 @ 48 kHz) 4328 */ 4329 USB_DEVICE(0x2b53, 0x0023), 4330 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4331 .vendor_name = "Fiero", 4332 .product_name = "SC-01", 4333 .ifnum = QUIRK_ANY_INTERFACE, 4334 .type = QUIRK_COMPOSITE, 4335 .data = &(const struct snd_usb_audio_quirk[]) { 4336 { 4337 .ifnum = 0, 4338 .type = QUIRK_AUDIO_STANDARD_INTERFACE 4339 }, 4340 /* Playback */ 4341 { 4342 .ifnum = 1, 4343 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4344 .data = &(const struct audioformat) { 4345 .formats = SNDRV_PCM_FMTBIT_S32_LE, 4346 .channels = 2, 4347 .fmt_bits = 24, 4348 .iface = 1, 4349 .altsetting = 1, 4350 .altset_idx = 1, 4351 .endpoint = 0x01, 4352 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4353 USB_ENDPOINT_SYNC_ASYNC, 4354 .rates = SNDRV_PCM_RATE_48000, 4355 .rate_min = 48000, 4356 .rate_max = 48000, 4357 .nr_rates = 1, 4358 .rate_table = (unsigned int[]) { 48000 }, 4359 .clock = 0x29 4360 } 4361 }, 4362 /* Capture */ 4363 { 4364 .ifnum = 2, 4365 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4366 .data = &(const struct audioformat) { 4367 .formats = SNDRV_PCM_FMTBIT_S32_LE, 4368 .channels = 2, 4369 .fmt_bits = 24, 4370 .iface = 2, 4371 .altsetting = 1, 4372 .altset_idx = 1, 4373 .endpoint = 0x82, 4374 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4375 USB_ENDPOINT_SYNC_ASYNC | 4376 USB_ENDPOINT_USAGE_IMPLICIT_FB, 4377 .rates = SNDRV_PCM_RATE_48000, 4378 .rate_min = 48000, 4379 .rate_max = 48000, 4380 .nr_rates = 1, 4381 .rate_table = (unsigned int[]) { 48000 }, 4382 .clock = 0x29 4383 } 4384 }, 4385 { 4386 .ifnum = -1 4387 } 4388 } 4389 } 4390 }, 4391 { 4392 /* 4393 * Fiero SC-01 (firmware v1.0.0 @ 96 kHz) 4394 */ 4395 USB_DEVICE(0x2b53, 0x0024), 4396 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4397 .vendor_name = "Fiero", 4398 .product_name = "SC-01", 4399 .ifnum = QUIRK_ANY_INTERFACE, 4400 .type = QUIRK_COMPOSITE, 4401 .data = &(const struct snd_usb_audio_quirk[]) { 4402 { 4403 .ifnum = 0, 4404 .type = QUIRK_AUDIO_STANDARD_INTERFACE 4405 }, 4406 /* Playback */ 4407 { 4408 .ifnum = 1, 4409 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4410 .data = &(const struct audioformat) { 4411 .formats = SNDRV_PCM_FMTBIT_S32_LE, 4412 .channels = 2, 4413 .fmt_bits = 24, 4414 .iface = 1, 4415 .altsetting = 1, 4416 .altset_idx = 1, 4417 .endpoint = 0x01, 4418 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4419 USB_ENDPOINT_SYNC_ASYNC, 4420 .rates = SNDRV_PCM_RATE_96000, 4421 .rate_min = 96000, 4422 .rate_max = 96000, 4423 .nr_rates = 1, 4424 .rate_table = (unsigned int[]) { 96000 }, 4425 .clock = 0x29 4426 } 4427 }, 4428 /* Capture */ 4429 { 4430 .ifnum = 2, 4431 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4432 .data = &(const struct audioformat) { 4433 .formats = SNDRV_PCM_FMTBIT_S32_LE, 4434 .channels = 2, 4435 .fmt_bits = 24, 4436 .iface = 2, 4437 .altsetting = 1, 4438 .altset_idx = 1, 4439 .endpoint = 0x82, 4440 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4441 USB_ENDPOINT_SYNC_ASYNC | 4442 USB_ENDPOINT_USAGE_IMPLICIT_FB, 4443 .rates = SNDRV_PCM_RATE_96000, 4444 .rate_min = 96000, 4445 .rate_max = 96000, 4446 .nr_rates = 1, 4447 .rate_table = (unsigned int[]) { 96000 }, 4448 .clock = 0x29 4449 } 4450 }, 4451 { 4452 .ifnum = -1 4453 } 4454 } 4455 } 4456 }, 4457 { 4458 /* 4459 * Fiero SC-01 (firmware v1.1.0) 4460 */ 4461 USB_DEVICE(0x2b53, 0x0031), 4462 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4463 .vendor_name = "Fiero", 4464 .product_name = "SC-01", 4465 .ifnum = QUIRK_ANY_INTERFACE, 4466 .type = QUIRK_COMPOSITE, 4467 .data = &(const struct snd_usb_audio_quirk[]) { 4468 { 4469 .ifnum = 0, 4470 .type = QUIRK_AUDIO_STANDARD_INTERFACE 4471 }, 4472 /* Playback */ 4473 { 4474 .ifnum = 1, 4475 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4476 .data = &(const struct audioformat) { 4477 .formats = SNDRV_PCM_FMTBIT_S32_LE, 4478 .channels = 2, 4479 .fmt_bits = 24, 4480 .iface = 1, 4481 .altsetting = 1, 4482 .altset_idx = 1, 4483 .endpoint = 0x01, 4484 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4485 USB_ENDPOINT_SYNC_ASYNC, 4486 .rates = SNDRV_PCM_RATE_48000 | 4487 SNDRV_PCM_RATE_96000, 4488 .rate_min = 48000, 4489 .rate_max = 96000, 4490 .nr_rates = 2, 4491 .rate_table = (unsigned int[]) { 48000, 96000 }, 4492 .clock = 0x29 4493 } 4494 }, 4495 /* Capture */ 4496 { 4497 .ifnum = 2, 4498 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 4499 .data = &(const struct audioformat) { 4500 .formats = SNDRV_PCM_FMTBIT_S32_LE, 4501 .channels = 2, 4502 .fmt_bits = 24, 4503 .iface = 2, 4504 .altsetting = 1, 4505 .altset_idx = 1, 4506 .endpoint = 0x82, 4507 .ep_attr = USB_ENDPOINT_XFER_ISOC | 4508 USB_ENDPOINT_SYNC_ASYNC | 4509 USB_ENDPOINT_USAGE_IMPLICIT_FB, 4510 .rates = SNDRV_PCM_RATE_48000 | 4511 SNDRV_PCM_RATE_96000, 4512 .rate_min = 48000, 4513 .rate_max = 96000, 4514 .nr_rates = 2, 4515 .rate_table = (unsigned int[]) { 48000, 96000 }, 4516 .clock = 0x29 4517 } 4518 }, 4519 { 4520 .ifnum = -1 4521 } 4522 } 4523 } 4524 }, 4525 { 4526 /* Advanced modes of the Mythware XA001AU. 4527 * For the standard mode, Mythware XA001AU has ID ffad:a001 4528 */ 4529 USB_DEVICE_VENDOR_SPEC(0xffad, 0xa001), 4530 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 4531 .vendor_name = "Mythware", 4532 .product_name = "XA001AU", 4533 .ifnum = QUIRK_ANY_INTERFACE, 4534 .type = QUIRK_COMPOSITE, 4535 .data = (const struct snd_usb_audio_quirk[]) { 4536 { 4537 .ifnum = 0, 4538 .type = QUIRK_IGNORE_INTERFACE, 4539 }, 4540 { 4541 .ifnum = 1, 4542 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 4543 }, 4544 { 4545 .ifnum = 2, 4546 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 4547 }, 4548 { 4549 .ifnum = -1 4550 } 4551 } 4552 } 4553 }, 4554 4555 #undef USB_DEVICE_VENDOR_SPEC 4556 #undef USB_AUDIO_DEVICE 4557