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