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 /* this catches most recent vendor-specific Roland devices */ 1720 { 1721 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 1722 USB_DEVICE_ID_MATCH_INT_CLASS, 1723 .idVendor = 0x0582, 1724 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 1725 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 1726 .ifnum = QUIRK_ANY_INTERFACE, 1727 .type = QUIRK_AUTODETECT 1728 } 1729 }, 1730 1731 /* Guillemot devices */ 1732 { 1733 /* 1734 * This is for the "Windows Edition" where the external MIDI ports are 1735 * the only MIDI ports; the control data is reported through HID 1736 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1737 * compliant USB MIDI ports for external MIDI and controls. 1738 */ 1739 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1740 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1741 .vendor_name = "Hercules", 1742 .product_name = "DJ Console (WE)", 1743 .ifnum = 4, 1744 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1745 .data = & (const struct snd_usb_midi_endpoint_info) { 1746 .out_cables = 0x0001, 1747 .in_cables = 0x0001 1748 } 1749 } 1750 }, 1751 1752 /* Midiman/M-Audio devices */ 1753 { 1754 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1755 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1756 .vendor_name = "M-Audio", 1757 .product_name = "MidiSport 2x2", 1758 .ifnum = QUIRK_ANY_INTERFACE, 1759 .type = QUIRK_MIDI_MIDIMAN, 1760 .data = & (const struct snd_usb_midi_endpoint_info) { 1761 .out_cables = 0x0003, 1762 .in_cables = 0x0003 1763 } 1764 } 1765 }, 1766 { 1767 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1768 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1769 .vendor_name = "M-Audio", 1770 .product_name = "MidiSport 1x1", 1771 .ifnum = QUIRK_ANY_INTERFACE, 1772 .type = QUIRK_MIDI_MIDIMAN, 1773 .data = & (const struct snd_usb_midi_endpoint_info) { 1774 .out_cables = 0x0001, 1775 .in_cables = 0x0001 1776 } 1777 } 1778 }, 1779 { 1780 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1781 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1782 .vendor_name = "M-Audio", 1783 .product_name = "Keystation", 1784 .ifnum = QUIRK_ANY_INTERFACE, 1785 .type = QUIRK_MIDI_MIDIMAN, 1786 .data = & (const struct snd_usb_midi_endpoint_info) { 1787 .out_cables = 0x0001, 1788 .in_cables = 0x0001 1789 } 1790 } 1791 }, 1792 { 1793 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1794 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1795 .vendor_name = "M-Audio", 1796 .product_name = "MidiSport 4x4", 1797 .ifnum = QUIRK_ANY_INTERFACE, 1798 .type = QUIRK_MIDI_MIDIMAN, 1799 .data = & (const struct snd_usb_midi_endpoint_info) { 1800 .out_cables = 0x000f, 1801 .in_cables = 0x000f 1802 } 1803 } 1804 }, 1805 { 1806 /* 1807 * For hardware revision 1.05; in the later revisions (1.10 and 1808 * 1.21), 0x1031 is the ID for the device without firmware. 1809 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1810 */ 1811 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1812 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1813 .vendor_name = "M-Audio", 1814 .product_name = "MidiSport 8x8", 1815 .ifnum = QUIRK_ANY_INTERFACE, 1816 .type = QUIRK_MIDI_MIDIMAN, 1817 .data = & (const struct snd_usb_midi_endpoint_info) { 1818 .out_cables = 0x01ff, 1819 .in_cables = 0x01ff 1820 } 1821 } 1822 }, 1823 { 1824 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1825 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1826 .vendor_name = "M-Audio", 1827 .product_name = "MidiSport 8x8", 1828 .ifnum = QUIRK_ANY_INTERFACE, 1829 .type = QUIRK_MIDI_MIDIMAN, 1830 .data = & (const struct snd_usb_midi_endpoint_info) { 1831 .out_cables = 0x01ff, 1832 .in_cables = 0x01ff 1833 } 1834 } 1835 }, 1836 { 1837 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1838 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1839 .vendor_name = "M-Audio", 1840 .product_name = "MidiSport 2x4", 1841 .ifnum = QUIRK_ANY_INTERFACE, 1842 .type = QUIRK_MIDI_MIDIMAN, 1843 .data = & (const struct snd_usb_midi_endpoint_info) { 1844 .out_cables = 0x000f, 1845 .in_cables = 0x0003 1846 } 1847 } 1848 }, 1849 { 1850 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1851 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1852 .vendor_name = "M-Audio", 1853 .product_name = "Quattro", 1854 .ifnum = QUIRK_ANY_INTERFACE, 1855 .type = QUIRK_COMPOSITE, 1856 .data = & (const struct snd_usb_audio_quirk[]) { 1857 /* 1858 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1859 * and share endpoints with the other interfaces. 1860 * Ignore them. The other interfaces can do 24 bits, 1861 * but captured samples are big-endian (see usbaudio.c). 1862 */ 1863 { 1864 .ifnum = 0, 1865 .type = QUIRK_IGNORE_INTERFACE 1866 }, 1867 { 1868 .ifnum = 1, 1869 .type = QUIRK_IGNORE_INTERFACE 1870 }, 1871 { 1872 .ifnum = 2, 1873 .type = QUIRK_IGNORE_INTERFACE 1874 }, 1875 { 1876 .ifnum = 3, 1877 .type = QUIRK_IGNORE_INTERFACE 1878 }, 1879 { 1880 .ifnum = 4, 1881 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1882 }, 1883 { 1884 .ifnum = 5, 1885 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1886 }, 1887 { 1888 .ifnum = 6, 1889 .type = QUIRK_IGNORE_INTERFACE 1890 }, 1891 { 1892 .ifnum = 7, 1893 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1894 }, 1895 { 1896 .ifnum = 8, 1897 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1898 }, 1899 { 1900 .ifnum = 9, 1901 .type = QUIRK_MIDI_MIDIMAN, 1902 .data = & (const struct snd_usb_midi_endpoint_info) { 1903 .out_cables = 0x0001, 1904 .in_cables = 0x0001 1905 } 1906 }, 1907 { 1908 .ifnum = -1 1909 } 1910 } 1911 } 1912 }, 1913 { 1914 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 1915 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1916 .vendor_name = "M-Audio", 1917 .product_name = "AudioPhile", 1918 .ifnum = 6, 1919 .type = QUIRK_MIDI_MIDIMAN, 1920 .data = & (const struct snd_usb_midi_endpoint_info) { 1921 .out_cables = 0x0001, 1922 .in_cables = 0x0001 1923 } 1924 } 1925 }, 1926 { 1927 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 1928 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1929 .vendor_name = "M-Audio", 1930 .product_name = "Ozone", 1931 .ifnum = 3, 1932 .type = QUIRK_MIDI_MIDIMAN, 1933 .data = & (const struct snd_usb_midi_endpoint_info) { 1934 .out_cables = 0x0001, 1935 .in_cables = 0x0001 1936 } 1937 } 1938 }, 1939 { 1940 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 1941 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1942 .vendor_name = "M-Audio", 1943 .product_name = "OmniStudio", 1944 .ifnum = QUIRK_ANY_INTERFACE, 1945 .type = QUIRK_COMPOSITE, 1946 .data = & (const struct snd_usb_audio_quirk[]) { 1947 { 1948 .ifnum = 0, 1949 .type = QUIRK_IGNORE_INTERFACE 1950 }, 1951 { 1952 .ifnum = 1, 1953 .type = QUIRK_IGNORE_INTERFACE 1954 }, 1955 { 1956 .ifnum = 2, 1957 .type = QUIRK_IGNORE_INTERFACE 1958 }, 1959 { 1960 .ifnum = 3, 1961 .type = QUIRK_IGNORE_INTERFACE 1962 }, 1963 { 1964 .ifnum = 4, 1965 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1966 }, 1967 { 1968 .ifnum = 5, 1969 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1970 }, 1971 { 1972 .ifnum = 6, 1973 .type = QUIRK_IGNORE_INTERFACE 1974 }, 1975 { 1976 .ifnum = 7, 1977 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1978 }, 1979 { 1980 .ifnum = 8, 1981 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1982 }, 1983 { 1984 .ifnum = 9, 1985 .type = QUIRK_MIDI_MIDIMAN, 1986 .data = & (const struct snd_usb_midi_endpoint_info) { 1987 .out_cables = 0x0001, 1988 .in_cables = 0x0001 1989 } 1990 }, 1991 { 1992 .ifnum = -1 1993 } 1994 } 1995 } 1996 }, 1997 { 1998 USB_DEVICE(0x0763, 0x2019), 1999 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2000 /* .vendor_name = "M-Audio", */ 2001 /* .product_name = "Ozone Academic", */ 2002 .ifnum = QUIRK_ANY_INTERFACE, 2003 .type = QUIRK_COMPOSITE, 2004 .data = & (const struct snd_usb_audio_quirk[]) { 2005 { 2006 .ifnum = 0, 2007 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2008 }, 2009 { 2010 .ifnum = 1, 2011 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2012 }, 2013 { 2014 .ifnum = 2, 2015 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2016 }, 2017 { 2018 .ifnum = 3, 2019 .type = QUIRK_MIDI_MIDIMAN, 2020 .data = & (const struct snd_usb_midi_endpoint_info) { 2021 .out_cables = 0x0001, 2022 .in_cables = 0x0001 2023 } 2024 }, 2025 { 2026 .ifnum = -1 2027 } 2028 } 2029 } 2030 }, 2031 { 2032 /* M-Audio Micro */ 2033 USB_DEVICE_VENDOR_SPEC(0x0763, 0x201a), 2034 }, 2035 { 2036 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030), 2037 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2038 /* .vendor_name = "M-Audio", */ 2039 /* .product_name = "Fast Track C400", */ 2040 .ifnum = QUIRK_ANY_INTERFACE, 2041 .type = QUIRK_COMPOSITE, 2042 .data = &(const struct snd_usb_audio_quirk[]) { 2043 { 2044 .ifnum = 1, 2045 .type = QUIRK_AUDIO_STANDARD_MIXER, 2046 }, 2047 /* Playback */ 2048 { 2049 .ifnum = 2, 2050 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2051 .data = &(const struct audioformat) { 2052 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2053 .channels = 6, 2054 .iface = 2, 2055 .altsetting = 1, 2056 .altset_idx = 1, 2057 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2058 .endpoint = 0x01, 2059 .ep_attr = 0x09, 2060 .rates = SNDRV_PCM_RATE_44100 | 2061 SNDRV_PCM_RATE_48000 | 2062 SNDRV_PCM_RATE_88200 | 2063 SNDRV_PCM_RATE_96000, 2064 .rate_min = 44100, 2065 .rate_max = 96000, 2066 .nr_rates = 4, 2067 .rate_table = (unsigned int[]) { 2068 44100, 48000, 88200, 96000 2069 }, 2070 .clock = 0x80, 2071 } 2072 }, 2073 /* Capture */ 2074 { 2075 .ifnum = 3, 2076 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2077 .data = &(const struct audioformat) { 2078 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2079 .channels = 4, 2080 .iface = 3, 2081 .altsetting = 1, 2082 .altset_idx = 1, 2083 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2084 .endpoint = 0x81, 2085 .ep_attr = 0x05, 2086 .rates = SNDRV_PCM_RATE_44100 | 2087 SNDRV_PCM_RATE_48000 | 2088 SNDRV_PCM_RATE_88200 | 2089 SNDRV_PCM_RATE_96000, 2090 .rate_min = 44100, 2091 .rate_max = 96000, 2092 .nr_rates = 4, 2093 .rate_table = (unsigned int[]) { 2094 44100, 48000, 88200, 96000 2095 }, 2096 .clock = 0x80, 2097 } 2098 }, 2099 /* MIDI */ 2100 { 2101 .ifnum = -1 /* Interface = 4 */ 2102 } 2103 } 2104 } 2105 }, 2106 { 2107 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031), 2108 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2109 /* .vendor_name = "M-Audio", */ 2110 /* .product_name = "Fast Track C600", */ 2111 .ifnum = QUIRK_ANY_INTERFACE, 2112 .type = QUIRK_COMPOSITE, 2113 .data = &(const struct snd_usb_audio_quirk[]) { 2114 { 2115 .ifnum = 1, 2116 .type = QUIRK_AUDIO_STANDARD_MIXER, 2117 }, 2118 /* Playback */ 2119 { 2120 .ifnum = 2, 2121 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2122 .data = &(const struct audioformat) { 2123 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2124 .channels = 8, 2125 .iface = 2, 2126 .altsetting = 1, 2127 .altset_idx = 1, 2128 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2129 .endpoint = 0x01, 2130 .ep_attr = 0x09, 2131 .rates = SNDRV_PCM_RATE_44100 | 2132 SNDRV_PCM_RATE_48000 | 2133 SNDRV_PCM_RATE_88200 | 2134 SNDRV_PCM_RATE_96000, 2135 .rate_min = 44100, 2136 .rate_max = 96000, 2137 .nr_rates = 4, 2138 .rate_table = (unsigned int[]) { 2139 44100, 48000, 88200, 96000 2140 }, 2141 .clock = 0x80, 2142 } 2143 }, 2144 /* Capture */ 2145 { 2146 .ifnum = 3, 2147 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2148 .data = &(const struct audioformat) { 2149 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2150 .channels = 6, 2151 .iface = 3, 2152 .altsetting = 1, 2153 .altset_idx = 1, 2154 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2155 .endpoint = 0x81, 2156 .ep_attr = 0x05, 2157 .rates = SNDRV_PCM_RATE_44100 | 2158 SNDRV_PCM_RATE_48000 | 2159 SNDRV_PCM_RATE_88200 | 2160 SNDRV_PCM_RATE_96000, 2161 .rate_min = 44100, 2162 .rate_max = 96000, 2163 .nr_rates = 4, 2164 .rate_table = (unsigned int[]) { 2165 44100, 48000, 88200, 96000 2166 }, 2167 .clock = 0x80, 2168 } 2169 }, 2170 /* MIDI */ 2171 { 2172 .ifnum = -1 /* Interface = 4 */ 2173 } 2174 } 2175 } 2176 }, 2177 { 2178 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080), 2179 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2180 /* .vendor_name = "M-Audio", */ 2181 /* .product_name = "Fast Track Ultra", */ 2182 .ifnum = QUIRK_ANY_INTERFACE, 2183 .type = QUIRK_COMPOSITE, 2184 .data = & (const struct snd_usb_audio_quirk[]) { 2185 { 2186 .ifnum = 0, 2187 .type = QUIRK_AUDIO_STANDARD_MIXER, 2188 }, 2189 { 2190 .ifnum = 1, 2191 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2192 .data = & (const struct audioformat) { 2193 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2194 .channels = 8, 2195 .iface = 1, 2196 .altsetting = 1, 2197 .altset_idx = 1, 2198 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2199 .endpoint = 0x01, 2200 .ep_attr = 0x09, 2201 .rates = SNDRV_PCM_RATE_44100 | 2202 SNDRV_PCM_RATE_48000 | 2203 SNDRV_PCM_RATE_88200 | 2204 SNDRV_PCM_RATE_96000, 2205 .rate_min = 44100, 2206 .rate_max = 96000, 2207 .nr_rates = 4, 2208 .rate_table = (unsigned int[]) { 2209 44100, 48000, 88200, 96000 2210 } 2211 } 2212 }, 2213 { 2214 .ifnum = 2, 2215 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2216 .data = & (const struct audioformat) { 2217 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2218 .channels = 8, 2219 .iface = 2, 2220 .altsetting = 1, 2221 .altset_idx = 1, 2222 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2223 .endpoint = 0x81, 2224 .ep_attr = 0x05, 2225 .rates = SNDRV_PCM_RATE_44100 | 2226 SNDRV_PCM_RATE_48000 | 2227 SNDRV_PCM_RATE_88200 | 2228 SNDRV_PCM_RATE_96000, 2229 .rate_min = 44100, 2230 .rate_max = 96000, 2231 .nr_rates = 4, 2232 .rate_table = (unsigned int[]) { 2233 44100, 48000, 88200, 96000 2234 } 2235 } 2236 }, 2237 /* interface 3 (MIDI) is standard compliant */ 2238 { 2239 .ifnum = -1 2240 } 2241 } 2242 } 2243 }, 2244 { 2245 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2246 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2247 /* .vendor_name = "M-Audio", */ 2248 /* .product_name = "Fast Track Ultra 8R", */ 2249 .ifnum = QUIRK_ANY_INTERFACE, 2250 .type = QUIRK_COMPOSITE, 2251 .data = & (const struct snd_usb_audio_quirk[]) { 2252 { 2253 .ifnum = 0, 2254 .type = QUIRK_AUDIO_STANDARD_MIXER, 2255 }, 2256 { 2257 .ifnum = 1, 2258 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2259 .data = & (const struct audioformat) { 2260 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2261 .channels = 8, 2262 .iface = 1, 2263 .altsetting = 1, 2264 .altset_idx = 1, 2265 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2266 .endpoint = 0x01, 2267 .ep_attr = 0x09, 2268 .rates = SNDRV_PCM_RATE_44100 | 2269 SNDRV_PCM_RATE_48000 | 2270 SNDRV_PCM_RATE_88200 | 2271 SNDRV_PCM_RATE_96000, 2272 .rate_min = 44100, 2273 .rate_max = 96000, 2274 .nr_rates = 4, 2275 .rate_table = (unsigned int[]) { 2276 44100, 48000, 88200, 96000 2277 } 2278 } 2279 }, 2280 { 2281 .ifnum = 2, 2282 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2283 .data = & (const struct audioformat) { 2284 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2285 .channels = 8, 2286 .iface = 2, 2287 .altsetting = 1, 2288 .altset_idx = 1, 2289 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2290 .endpoint = 0x81, 2291 .ep_attr = 0x05, 2292 .rates = SNDRV_PCM_RATE_44100 | 2293 SNDRV_PCM_RATE_48000 | 2294 SNDRV_PCM_RATE_88200 | 2295 SNDRV_PCM_RATE_96000, 2296 .rate_min = 44100, 2297 .rate_max = 96000, 2298 .nr_rates = 4, 2299 .rate_table = (unsigned int[]) { 2300 44100, 48000, 88200, 96000 2301 } 2302 } 2303 }, 2304 /* interface 3 (MIDI) is standard compliant */ 2305 { 2306 .ifnum = -1 2307 } 2308 } 2309 } 2310 }, 2311 2312 /* Casio devices */ 2313 { 2314 USB_DEVICE(0x07cf, 0x6801), 2315 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2316 .vendor_name = "Casio", 2317 .product_name = "PL-40R", 2318 .ifnum = 0, 2319 .type = QUIRK_MIDI_YAMAHA 2320 } 2321 }, 2322 { 2323 /* this ID is used by several devices without a product ID */ 2324 USB_DEVICE(0x07cf, 0x6802), 2325 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2326 .vendor_name = "Casio", 2327 .product_name = "Keyboard", 2328 .ifnum = 0, 2329 .type = QUIRK_MIDI_YAMAHA 2330 } 2331 }, 2332 2333 /* Mark of the Unicorn devices */ 2334 { 2335 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2336 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2337 USB_DEVICE_ID_MATCH_PRODUCT | 2338 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2339 .idVendor = 0x07fd, 2340 .idProduct = 0x0001, 2341 .bDeviceSubClass = 2, 2342 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2343 .vendor_name = "MOTU", 2344 .product_name = "Fastlane", 2345 .ifnum = QUIRK_ANY_INTERFACE, 2346 .type = QUIRK_COMPOSITE, 2347 .data = & (const struct snd_usb_audio_quirk[]) { 2348 { 2349 .ifnum = 0, 2350 .type = QUIRK_MIDI_RAW_BYTES 2351 }, 2352 { 2353 .ifnum = 1, 2354 .type = QUIRK_IGNORE_INTERFACE 2355 }, 2356 { 2357 .ifnum = -1 2358 } 2359 } 2360 } 2361 }, 2362 2363 /* Emagic devices */ 2364 { 2365 USB_DEVICE(0x086a, 0x0001), 2366 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2367 .vendor_name = "Emagic", 2368 .product_name = "Unitor8", 2369 .ifnum = 2, 2370 .type = QUIRK_MIDI_EMAGIC, 2371 .data = & (const struct snd_usb_midi_endpoint_info) { 2372 .out_cables = 0x80ff, 2373 .in_cables = 0x80ff 2374 } 2375 } 2376 }, 2377 { 2378 USB_DEVICE(0x086a, 0x0002), 2379 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2380 .vendor_name = "Emagic", 2381 /* .product_name = "AMT8", */ 2382 .ifnum = 2, 2383 .type = QUIRK_MIDI_EMAGIC, 2384 .data = & (const struct snd_usb_midi_endpoint_info) { 2385 .out_cables = 0x80ff, 2386 .in_cables = 0x80ff 2387 } 2388 } 2389 }, 2390 { 2391 USB_DEVICE(0x086a, 0x0003), 2392 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2393 .vendor_name = "Emagic", 2394 /* .product_name = "MT4", */ 2395 .ifnum = 2, 2396 .type = QUIRK_MIDI_EMAGIC, 2397 .data = & (const struct snd_usb_midi_endpoint_info) { 2398 .out_cables = 0x800f, 2399 .in_cables = 0x8003 2400 } 2401 } 2402 }, 2403 2404 /* KORG devices */ 2405 { 2406 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2407 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2408 .vendor_name = "KORG, Inc.", 2409 /* .product_name = "PANDORA PX5D", */ 2410 .ifnum = 3, 2411 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2412 } 2413 }, 2414 2415 { 2416 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201), 2417 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2418 .vendor_name = "KORG, Inc.", 2419 /* .product_name = "ToneLab ST", */ 2420 .ifnum = 3, 2421 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2422 } 2423 }, 2424 2425 { 2426 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0204), 2427 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2428 .vendor_name = "KORG, Inc.", 2429 /* .product_name = "ToneLab EX", */ 2430 .ifnum = 3, 2431 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2432 } 2433 }, 2434 2435 /* AKAI devices */ 2436 { 2437 USB_DEVICE(0x09e8, 0x0062), 2438 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2439 .vendor_name = "AKAI", 2440 .product_name = "MPD16", 2441 .ifnum = 0, 2442 .type = QUIRK_MIDI_AKAI, 2443 } 2444 }, 2445 2446 { 2447 /* Akai MPC Element */ 2448 USB_DEVICE(0x09e8, 0x0021), 2449 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2450 .ifnum = QUIRK_ANY_INTERFACE, 2451 .type = QUIRK_COMPOSITE, 2452 .data = & (const struct snd_usb_audio_quirk[]) { 2453 { 2454 .ifnum = 0, 2455 .type = QUIRK_IGNORE_INTERFACE 2456 }, 2457 { 2458 .ifnum = 1, 2459 .type = QUIRK_MIDI_STANDARD_INTERFACE 2460 }, 2461 { 2462 .ifnum = -1 2463 } 2464 } 2465 } 2466 }, 2467 2468 /* Steinberg devices */ 2469 { 2470 /* Steinberg MI2 */ 2471 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040), 2472 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2473 .ifnum = QUIRK_ANY_INTERFACE, 2474 .type = QUIRK_COMPOSITE, 2475 .data = & (const struct snd_usb_audio_quirk[]) { 2476 { 2477 .ifnum = 0, 2478 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2479 }, 2480 { 2481 .ifnum = 1, 2482 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2483 }, 2484 { 2485 .ifnum = 2, 2486 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2487 }, 2488 { 2489 .ifnum = 3, 2490 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2491 .data = &(const struct snd_usb_midi_endpoint_info) { 2492 .out_cables = 0x0001, 2493 .in_cables = 0x0001 2494 } 2495 }, 2496 { 2497 .ifnum = -1 2498 } 2499 } 2500 } 2501 }, 2502 { 2503 /* Steinberg MI4 */ 2504 USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040), 2505 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2506 .ifnum = QUIRK_ANY_INTERFACE, 2507 .type = QUIRK_COMPOSITE, 2508 .data = & (const struct snd_usb_audio_quirk[]) { 2509 { 2510 .ifnum = 0, 2511 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2512 }, 2513 { 2514 .ifnum = 1, 2515 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2516 }, 2517 { 2518 .ifnum = 2, 2519 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2520 }, 2521 { 2522 .ifnum = 3, 2523 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2524 .data = &(const struct snd_usb_midi_endpoint_info) { 2525 .out_cables = 0x0001, 2526 .in_cables = 0x0001 2527 } 2528 }, 2529 { 2530 .ifnum = -1 2531 } 2532 } 2533 } 2534 }, 2535 2536 /* TerraTec devices */ 2537 { 2538 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2539 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2540 .vendor_name = "TerraTec", 2541 .product_name = "PHASE 26", 2542 .ifnum = 3, 2543 .type = QUIRK_MIDI_STANDARD_INTERFACE 2544 } 2545 }, 2546 { 2547 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2548 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2549 .vendor_name = "TerraTec", 2550 .product_name = "PHASE 26", 2551 .ifnum = 3, 2552 .type = QUIRK_MIDI_STANDARD_INTERFACE 2553 } 2554 }, 2555 { 2556 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2557 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2558 .vendor_name = "TerraTec", 2559 .product_name = "PHASE 26", 2560 .ifnum = 3, 2561 .type = QUIRK_MIDI_STANDARD_INTERFACE 2562 } 2563 }, 2564 { 2565 USB_DEVICE(0x0ccd, 0x0035), 2566 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2567 .vendor_name = "Miditech", 2568 .product_name = "Play'n Roll", 2569 .ifnum = 0, 2570 .type = QUIRK_MIDI_CME 2571 } 2572 }, 2573 2574 /* Novation EMS devices */ 2575 { 2576 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2577 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2578 .vendor_name = "Novation", 2579 .product_name = "ReMOTE Audio/XStation", 2580 .ifnum = 4, 2581 .type = QUIRK_MIDI_NOVATION 2582 } 2583 }, 2584 { 2585 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2586 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2587 .vendor_name = "Novation", 2588 .product_name = "Speedio", 2589 .ifnum = 3, 2590 .type = QUIRK_MIDI_NOVATION 2591 } 2592 }, 2593 { 2594 USB_DEVICE(0x1235, 0x000a), 2595 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2596 /* .vendor_name = "Novation", */ 2597 /* .product_name = "Nocturn", */ 2598 .ifnum = 0, 2599 .type = QUIRK_MIDI_RAW_BYTES 2600 } 2601 }, 2602 { 2603 USB_DEVICE(0x1235, 0x000e), 2604 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2605 /* .vendor_name = "Novation", */ 2606 /* .product_name = "Launchpad", */ 2607 .ifnum = 0, 2608 .type = QUIRK_MIDI_RAW_BYTES 2609 } 2610 }, 2611 { 2612 USB_DEVICE(0x1235, 0x0010), 2613 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2614 .vendor_name = "Focusrite", 2615 .product_name = "Saffire 6 USB", 2616 .ifnum = QUIRK_ANY_INTERFACE, 2617 .type = QUIRK_COMPOSITE, 2618 .data = (const struct snd_usb_audio_quirk[]) { 2619 { 2620 .ifnum = 0, 2621 .type = QUIRK_AUDIO_STANDARD_MIXER, 2622 }, 2623 { 2624 .ifnum = 0, 2625 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2626 .data = &(const struct audioformat) { 2627 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2628 .channels = 4, 2629 .iface = 0, 2630 .altsetting = 1, 2631 .altset_idx = 1, 2632 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2633 .endpoint = 0x01, 2634 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2635 .datainterval = 1, 2636 .maxpacksize = 0x024c, 2637 .rates = SNDRV_PCM_RATE_44100 | 2638 SNDRV_PCM_RATE_48000, 2639 .rate_min = 44100, 2640 .rate_max = 48000, 2641 .nr_rates = 2, 2642 .rate_table = (unsigned int[]) { 2643 44100, 48000 2644 } 2645 } 2646 }, 2647 { 2648 .ifnum = 0, 2649 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2650 .data = &(const struct audioformat) { 2651 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2652 .channels = 2, 2653 .iface = 0, 2654 .altsetting = 1, 2655 .altset_idx = 1, 2656 .attributes = 0, 2657 .endpoint = 0x82, 2658 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2659 .datainterval = 1, 2660 .maxpacksize = 0x0126, 2661 .rates = SNDRV_PCM_RATE_44100 | 2662 SNDRV_PCM_RATE_48000, 2663 .rate_min = 44100, 2664 .rate_max = 48000, 2665 .nr_rates = 2, 2666 .rate_table = (unsigned int[]) { 2667 44100, 48000 2668 } 2669 } 2670 }, 2671 { 2672 .ifnum = 1, 2673 .type = QUIRK_MIDI_RAW_BYTES 2674 }, 2675 { 2676 .ifnum = -1 2677 } 2678 } 2679 } 2680 }, 2681 { 2682 USB_DEVICE(0x1235, 0x0018), 2683 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2684 .vendor_name = "Novation", 2685 .product_name = "Twitch", 2686 .ifnum = QUIRK_ANY_INTERFACE, 2687 .type = QUIRK_COMPOSITE, 2688 .data = (const struct snd_usb_audio_quirk[]) { 2689 { 2690 .ifnum = 0, 2691 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2692 .data = & (const struct audioformat) { 2693 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2694 .channels = 4, 2695 .iface = 0, 2696 .altsetting = 1, 2697 .altset_idx = 1, 2698 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2699 .endpoint = 0x01, 2700 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2701 .rates = SNDRV_PCM_RATE_44100 | 2702 SNDRV_PCM_RATE_48000, 2703 .rate_min = 44100, 2704 .rate_max = 48000, 2705 .nr_rates = 2, 2706 .rate_table = (unsigned int[]) { 2707 44100, 48000 2708 } 2709 } 2710 }, 2711 { 2712 .ifnum = 1, 2713 .type = QUIRK_MIDI_RAW_BYTES 2714 }, 2715 { 2716 .ifnum = -1 2717 } 2718 } 2719 } 2720 }, 2721 { 2722 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2723 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2724 .vendor_name = "Novation", 2725 .product_name = "ReMOTE25", 2726 .ifnum = 0, 2727 .type = QUIRK_MIDI_NOVATION 2728 } 2729 }, 2730 2731 /* Access Music devices */ 2732 { 2733 /* VirusTI Desktop */ 2734 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2735 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2736 .ifnum = QUIRK_ANY_INTERFACE, 2737 .type = QUIRK_COMPOSITE, 2738 .data = &(const struct snd_usb_audio_quirk[]) { 2739 { 2740 .ifnum = 3, 2741 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2742 .data = &(const struct snd_usb_midi_endpoint_info) { 2743 .out_cables = 0x0003, 2744 .in_cables = 0x0003 2745 } 2746 }, 2747 { 2748 .ifnum = 4, 2749 .type = QUIRK_IGNORE_INTERFACE 2750 }, 2751 { 2752 .ifnum = -1 2753 } 2754 } 2755 } 2756 }, 2757 2758 /* Lenovo ThinkStation P620 Rear Line-in, Line-out and Microphone */ 2759 { 2760 USB_DEVICE(0x17aa, 0x1046), 2761 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2762 .ifnum = QUIRK_ANY_INTERFACE, 2763 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND 2764 } 2765 }, 2766 /* Lenovo ThinkStation P620 Internal Speaker + Front Headset */ 2767 { 2768 USB_DEVICE(0x17aa, 0x104d), 2769 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2770 .ifnum = QUIRK_ANY_INTERFACE, 2771 .type = QUIRK_SETUP_DISABLE_AUTOSUSPEND 2772 } 2773 }, 2774 2775 /* Native Instruments MK2 series */ 2776 { 2777 /* Komplete Audio 6 */ 2778 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2779 .idVendor = 0x17cc, 2780 .idProduct = 0x1000, 2781 }, 2782 { 2783 /* Traktor Audio 6 */ 2784 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2785 .idVendor = 0x17cc, 2786 .idProduct = 0x1010, 2787 }, 2788 { 2789 /* Traktor Audio 10 */ 2790 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2791 .idVendor = 0x17cc, 2792 .idProduct = 0x1020, 2793 }, 2794 2795 /* QinHeng devices */ 2796 { 2797 USB_DEVICE(0x1a86, 0x752d), 2798 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2799 .vendor_name = "QinHeng", 2800 .product_name = "CH345", 2801 .ifnum = 1, 2802 .type = QUIRK_MIDI_CH345 2803 } 2804 }, 2805 2806 /* KeithMcMillen Stringport */ 2807 { USB_DEVICE(0x1f38, 0x0001) }, /* FIXME: should be more restrictive matching */ 2808 2809 /* Miditech devices */ 2810 { 2811 USB_DEVICE(0x4752, 0x0011), 2812 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2813 .vendor_name = "Miditech", 2814 .product_name = "Midistart-2", 2815 .ifnum = 0, 2816 .type = QUIRK_MIDI_CME 2817 } 2818 }, 2819 2820 /* Central Music devices */ 2821 { 2822 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2823 USB_DEVICE(0x7104, 0x2202), 2824 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2825 .ifnum = 0, 2826 .type = QUIRK_MIDI_CME 2827 } 2828 }, 2829 2830 /* 2831 * Auvitek au0828 devices with audio interface. 2832 * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c 2833 * Please notice that some drivers are DVB only, and don't need to be 2834 * here. That's the case, for example, of DVICO_FUSIONHDTV7. 2835 */ 2836 2837 #define AU0828_DEVICE(vid, pid, vname, pname) { \ 2838 USB_AUDIO_DEVICE(vid, pid), \ 2839 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \ 2840 .vendor_name = vname, \ 2841 .product_name = pname, \ 2842 .ifnum = QUIRK_ANY_INTERFACE, \ 2843 .type = QUIRK_AUDIO_ALIGN_TRANSFER, \ 2844 .shares_media_device = 1, \ 2845 } \ 2846 } 2847 2848 AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"), 2849 AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"), 2850 AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"), 2851 AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"), 2852 AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"), 2853 AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"), 2854 AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"), 2855 AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"), 2856 AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"), 2857 AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"), 2858 AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"), 2859 AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"), 2860 AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"), 2861 AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"), 2862 AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"), 2863 AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"), 2864 AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"), 2865 2866 /* Syntek STK1160 */ 2867 { 2868 USB_AUDIO_DEVICE(0x05e1, 0x0408), 2869 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2870 .vendor_name = "Syntek", 2871 .product_name = "STK1160", 2872 .ifnum = QUIRK_ANY_INTERFACE, 2873 .type = QUIRK_AUDIO_ALIGN_TRANSFER 2874 } 2875 }, 2876 2877 /* Digidesign Mbox */ 2878 { 2879 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2880 USB_DEVICE(0x0dba, 0x1000), 2881 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2882 .vendor_name = "Digidesign", 2883 .product_name = "MBox", 2884 .ifnum = QUIRK_ANY_INTERFACE, 2885 .type = QUIRK_COMPOSITE, 2886 .data = (const struct snd_usb_audio_quirk[]){ 2887 { 2888 .ifnum = 0, 2889 .type = QUIRK_AUDIO_STANDARD_MIXER, 2890 }, 2891 { 2892 .ifnum = 1, 2893 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2894 .data = &(const struct audioformat) { 2895 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2896 .channels = 2, 2897 .iface = 1, 2898 .altsetting = 1, 2899 .altset_idx = 1, 2900 .attributes = 0x4, 2901 .endpoint = 0x02, 2902 .ep_attr = USB_ENDPOINT_XFER_ISOC | 2903 USB_ENDPOINT_SYNC_SYNC, 2904 .maxpacksize = 0x130, 2905 .rates = SNDRV_PCM_RATE_48000, 2906 .rate_min = 48000, 2907 .rate_max = 48000, 2908 .nr_rates = 1, 2909 .rate_table = (unsigned int[]) { 2910 48000 2911 } 2912 } 2913 }, 2914 { 2915 .ifnum = 1, 2916 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2917 .data = &(const struct audioformat) { 2918 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2919 .channels = 2, 2920 .iface = 1, 2921 .altsetting = 1, 2922 .altset_idx = 1, 2923 .attributes = 0x4, 2924 .endpoint = 0x81, 2925 .ep_attr = USB_ENDPOINT_XFER_ISOC | 2926 USB_ENDPOINT_SYNC_ASYNC, 2927 .maxpacksize = 0x130, 2928 .rates = SNDRV_PCM_RATE_48000, 2929 .rate_min = 48000, 2930 .rate_max = 48000, 2931 .nr_rates = 1, 2932 .rate_table = (unsigned int[]) { 2933 48000 2934 } 2935 } 2936 }, 2937 { 2938 .ifnum = -1 2939 } 2940 } 2941 } 2942 }, 2943 2944 /* DIGIDESIGN MBOX 2 */ 2945 { 2946 USB_DEVICE(0x0dba, 0x3000), 2947 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2948 .vendor_name = "Digidesign", 2949 .product_name = "Mbox 2", 2950 .ifnum = QUIRK_ANY_INTERFACE, 2951 .type = QUIRK_COMPOSITE, 2952 .data = (const struct snd_usb_audio_quirk[]) { 2953 { 2954 .ifnum = 0, 2955 .type = QUIRK_IGNORE_INTERFACE 2956 }, 2957 { 2958 .ifnum = 1, 2959 .type = QUIRK_IGNORE_INTERFACE 2960 }, 2961 { 2962 .ifnum = 2, 2963 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2964 .data = &(const struct audioformat) { 2965 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2966 .channels = 2, 2967 .iface = 2, 2968 .altsetting = 2, 2969 .altset_idx = 1, 2970 .attributes = 0x00, 2971 .endpoint = 0x03, 2972 .ep_attr = USB_ENDPOINT_SYNC_ASYNC, 2973 .rates = SNDRV_PCM_RATE_48000, 2974 .rate_min = 48000, 2975 .rate_max = 48000, 2976 .nr_rates = 1, 2977 .rate_table = (unsigned int[]) { 2978 48000 2979 } 2980 } 2981 }, 2982 { 2983 .ifnum = 3, 2984 .type = QUIRK_IGNORE_INTERFACE 2985 }, 2986 { 2987 .ifnum = 4, 2988 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2989 .data = &(const struct audioformat) { 2990 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2991 .channels = 2, 2992 .iface = 4, 2993 .altsetting = 2, 2994 .altset_idx = 1, 2995 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2996 .endpoint = 0x85, 2997 .ep_attr = USB_ENDPOINT_SYNC_SYNC, 2998 .rates = SNDRV_PCM_RATE_48000, 2999 .rate_min = 48000, 3000 .rate_max = 48000, 3001 .nr_rates = 1, 3002 .rate_table = (unsigned int[]) { 3003 48000 3004 } 3005 } 3006 }, 3007 { 3008 .ifnum = 5, 3009 .type = QUIRK_IGNORE_INTERFACE 3010 }, 3011 { 3012 .ifnum = 6, 3013 .type = QUIRK_MIDI_MIDIMAN, 3014 .data = &(const struct snd_usb_midi_endpoint_info) { 3015 .out_ep = 0x02, 3016 .out_cables = 0x0001, 3017 .in_ep = 0x81, 3018 .in_interval = 0x01, 3019 .in_cables = 0x0001 3020 } 3021 }, 3022 { 3023 .ifnum = -1 3024 } 3025 } 3026 } 3027 }, 3028 { 3029 /* Tascam US122 MKII - playback-only support */ 3030 USB_DEVICE_VENDOR_SPEC(0x0644, 0x8021), 3031 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3032 .vendor_name = "TASCAM", 3033 .product_name = "US122 MKII", 3034 .ifnum = QUIRK_ANY_INTERFACE, 3035 .type = QUIRK_COMPOSITE, 3036 .data = (const struct snd_usb_audio_quirk[]) { 3037 { 3038 .ifnum = 0, 3039 .type = QUIRK_IGNORE_INTERFACE 3040 }, 3041 { 3042 .ifnum = 1, 3043 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3044 .data = &(const struct audioformat) { 3045 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3046 .channels = 2, 3047 .iface = 1, 3048 .altsetting = 1, 3049 .altset_idx = 1, 3050 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3051 .endpoint = 0x02, 3052 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3053 .rates = SNDRV_PCM_RATE_44100 | 3054 SNDRV_PCM_RATE_48000 | 3055 SNDRV_PCM_RATE_88200 | 3056 SNDRV_PCM_RATE_96000, 3057 .rate_min = 44100, 3058 .rate_max = 96000, 3059 .nr_rates = 4, 3060 .rate_table = (unsigned int[]) { 3061 44100, 48000, 88200, 96000 3062 } 3063 } 3064 }, 3065 { 3066 .ifnum = -1 3067 } 3068 } 3069 } 3070 }, 3071 3072 /* Microsoft XboxLive Headset/Xbox Communicator */ 3073 { 3074 USB_DEVICE(0x045e, 0x0283), 3075 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3076 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3077 .vendor_name = "Microsoft", 3078 .product_name = "XboxLive Headset/Xbox Communicator", 3079 .ifnum = QUIRK_ANY_INTERFACE, 3080 .type = QUIRK_COMPOSITE, 3081 .data = &(const struct snd_usb_audio_quirk[]) { 3082 { 3083 /* playback */ 3084 .ifnum = 0, 3085 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3086 .data = &(const struct audioformat) { 3087 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3088 .channels = 1, 3089 .iface = 0, 3090 .altsetting = 0, 3091 .altset_idx = 0, 3092 .attributes = 0, 3093 .endpoint = 0x04, 3094 .ep_attr = 0x05, 3095 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3096 .rate_min = 22050, 3097 .rate_max = 22050 3098 } 3099 }, 3100 { 3101 /* capture */ 3102 .ifnum = 1, 3103 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3104 .data = &(const struct audioformat) { 3105 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3106 .channels = 1, 3107 .iface = 1, 3108 .altsetting = 0, 3109 .altset_idx = 0, 3110 .attributes = 0, 3111 .endpoint = 0x85, 3112 .ep_attr = 0x05, 3113 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3114 .rate_min = 16000, 3115 .rate_max = 16000 3116 } 3117 }, 3118 { 3119 .ifnum = -1 3120 } 3121 } 3122 } 3123 }, 3124 3125 /* Reloop Play */ 3126 { 3127 USB_DEVICE(0x200c, 0x100b), 3128 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3129 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3130 .ifnum = QUIRK_ANY_INTERFACE, 3131 .type = QUIRK_COMPOSITE, 3132 .data = &(const struct snd_usb_audio_quirk[]) { 3133 { 3134 .ifnum = 0, 3135 .type = QUIRK_AUDIO_STANDARD_MIXER, 3136 }, 3137 { 3138 .ifnum = 1, 3139 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3140 .data = &(const struct audioformat) { 3141 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3142 .channels = 4, 3143 .iface = 1, 3144 .altsetting = 1, 3145 .altset_idx = 1, 3146 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3147 .endpoint = 0x01, 3148 .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE, 3149 .rates = SNDRV_PCM_RATE_44100 | 3150 SNDRV_PCM_RATE_48000, 3151 .rate_min = 44100, 3152 .rate_max = 48000, 3153 .nr_rates = 2, 3154 .rate_table = (unsigned int[]) { 3155 44100, 48000 3156 } 3157 } 3158 }, 3159 { 3160 .ifnum = -1 3161 } 3162 } 3163 } 3164 }, 3165 3166 { 3167 /* 3168 * ZOOM R16/24 in audio interface mode. 3169 * Playback requires an extra four byte LE length indicator 3170 * at the start of each isochronous packet. This quirk is 3171 * enabled in create_standard_audio_quirk(). 3172 */ 3173 USB_DEVICE(0x1686, 0x00dd), 3174 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3175 .ifnum = QUIRK_ANY_INTERFACE, 3176 .type = QUIRK_COMPOSITE, 3177 .data = (const struct snd_usb_audio_quirk[]) { 3178 { 3179 /* Playback */ 3180 .ifnum = 1, 3181 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 3182 }, 3183 { 3184 /* Capture */ 3185 .ifnum = 2, 3186 .type = QUIRK_AUDIO_STANDARD_INTERFACE, 3187 }, 3188 { 3189 /* Midi */ 3190 .ifnum = 3, 3191 .type = QUIRK_MIDI_STANDARD_INTERFACE 3192 }, 3193 { 3194 .ifnum = -1 3195 }, 3196 } 3197 } 3198 }, 3199 3200 { 3201 /* 3202 * Some USB MIDI devices don't have an audio control interface, 3203 * so we have to grab MIDI streaming interfaces here. 3204 */ 3205 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 3206 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 3207 .bInterfaceClass = USB_CLASS_AUDIO, 3208 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 3209 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3210 .ifnum = QUIRK_ANY_INTERFACE, 3211 .type = QUIRK_MIDI_STANDARD_INTERFACE 3212 } 3213 }, 3214 3215 /* Rane SL-1 */ 3216 { 3217 USB_DEVICE(0x13e5, 0x0001), 3218 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3219 .ifnum = QUIRK_ANY_INTERFACE, 3220 .type = QUIRK_AUDIO_STANDARD_INTERFACE 3221 } 3222 }, 3223 3224 /* disabled due to regression for other devices; 3225 * see https://bugzilla.kernel.org/show_bug.cgi?id=199905 3226 */ 3227 #if 0 3228 { 3229 /* 3230 * Nura's first gen headphones use Cambridge Silicon Radio's vendor 3231 * ID, but it looks like the product ID actually is only for Nura. 3232 * The capture interface does not work at all (even on Windows), 3233 * and only the 48 kHz sample rate works for the playback interface. 3234 */ 3235 USB_DEVICE(0x0a12, 0x1243), 3236 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3237 .ifnum = QUIRK_ANY_INTERFACE, 3238 .type = QUIRK_COMPOSITE, 3239 .data = (const struct snd_usb_audio_quirk[]) { 3240 { 3241 .ifnum = 0, 3242 .type = QUIRK_AUDIO_STANDARD_MIXER, 3243 }, 3244 /* Capture */ 3245 { 3246 .ifnum = 1, 3247 .type = QUIRK_IGNORE_INTERFACE, 3248 }, 3249 /* Playback */ 3250 { 3251 .ifnum = 2, 3252 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3253 .data = &(const struct audioformat) { 3254 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3255 .channels = 2, 3256 .iface = 2, 3257 .altsetting = 1, 3258 .altset_idx = 1, 3259 .attributes = UAC_EP_CS_ATTR_FILL_MAX | 3260 UAC_EP_CS_ATTR_SAMPLE_RATE, 3261 .endpoint = 0x03, 3262 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3263 .rates = SNDRV_PCM_RATE_48000, 3264 .rate_min = 48000, 3265 .rate_max = 48000, 3266 .nr_rates = 1, 3267 .rate_table = (unsigned int[]) { 3268 48000 3269 } 3270 } 3271 }, 3272 { 3273 .ifnum = -1 3274 }, 3275 } 3276 } 3277 }, 3278 #endif /* disabled */ 3279 3280 { 3281 /* 3282 * Bower's & Wilkins PX headphones only support the 48 kHz sample rate 3283 * even though it advertises more. The capture interface doesn't work 3284 * even on windows. 3285 */ 3286 USB_DEVICE(0x19b5, 0x0021), 3287 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3288 .ifnum = QUIRK_ANY_INTERFACE, 3289 .type = QUIRK_COMPOSITE, 3290 .data = (const struct snd_usb_audio_quirk[]) { 3291 { 3292 .ifnum = 0, 3293 .type = QUIRK_AUDIO_STANDARD_MIXER, 3294 }, 3295 /* Playback */ 3296 { 3297 .ifnum = 1, 3298 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3299 .data = &(const struct audioformat) { 3300 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3301 .channels = 2, 3302 .iface = 1, 3303 .altsetting = 1, 3304 .altset_idx = 1, 3305 .attributes = UAC_EP_CS_ATTR_FILL_MAX | 3306 UAC_EP_CS_ATTR_SAMPLE_RATE, 3307 .endpoint = 0x03, 3308 .ep_attr = USB_ENDPOINT_XFER_ISOC, 3309 .rates = SNDRV_PCM_RATE_48000, 3310 .rate_min = 48000, 3311 .rate_max = 48000, 3312 .nr_rates = 1, 3313 .rate_table = (unsigned int[]) { 3314 48000 3315 } 3316 } 3317 }, 3318 { 3319 .ifnum = -1 3320 }, 3321 } 3322 } 3323 }, 3324 /* Dell WD19 Dock */ 3325 { 3326 USB_DEVICE(0x0bda, 0x402e), 3327 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3328 .ifnum = QUIRK_ANY_INTERFACE, 3329 .type = QUIRK_SETUP_FMT_AFTER_RESUME 3330 } 3331 }, 3332 /* MOTU Microbook II */ 3333 { 3334 USB_DEVICE_VENDOR_SPEC(0x07fd, 0x0004), 3335 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3336 .vendor_name = "MOTU", 3337 .product_name = "MicroBookII", 3338 .ifnum = QUIRK_ANY_INTERFACE, 3339 .type = QUIRK_COMPOSITE, 3340 .data = (const struct snd_usb_audio_quirk[]) { 3341 { 3342 .ifnum = 0, 3343 .type = QUIRK_AUDIO_STANDARD_MIXER, 3344 }, 3345 { 3346 .ifnum = 0, 3347 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3348 .data = &(const struct audioformat) { 3349 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3350 .channels = 6, 3351 .iface = 0, 3352 .altsetting = 1, 3353 .altset_idx = 1, 3354 .attributes = 0, 3355 .endpoint = 0x84, 3356 .rates = SNDRV_PCM_RATE_96000, 3357 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3358 USB_ENDPOINT_SYNC_ASYNC, 3359 .rate_min = 96000, 3360 .rate_max = 96000, 3361 .nr_rates = 1, 3362 .maxpacksize = 0x00d8, 3363 .rate_table = (unsigned int[]) { 3364 96000 3365 } 3366 } 3367 }, 3368 { 3369 .ifnum = 0, 3370 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3371 .data = &(const struct audioformat) { 3372 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 3373 .channels = 8, 3374 .iface = 0, 3375 .altsetting = 1, 3376 .altset_idx = 1, 3377 .attributes = 0, 3378 .endpoint = 0x03, 3379 .rates = SNDRV_PCM_RATE_96000, 3380 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3381 USB_ENDPOINT_SYNC_ASYNC, 3382 .rate_min = 96000, 3383 .rate_max = 96000, 3384 .nr_rates = 1, 3385 .maxpacksize = 0x0120, 3386 .rate_table = (unsigned int[]) { 3387 96000 3388 } 3389 } 3390 }, 3391 { 3392 .ifnum = -1 3393 } 3394 } 3395 } 3396 }, 3397 { 3398 /* 3399 * PIONEER DJ DDJ-SX3 3400 * PCM is 12 channels out, 10 channels in @ 44.1 fixed 3401 * interface 0, vendor class alt setting 1 for endpoints 5 and 0x86 3402 * The feedback for the output is the input. 3403 */ 3404 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0023), 3405 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3406 .ifnum = QUIRK_ANY_INTERFACE, 3407 .type = QUIRK_COMPOSITE, 3408 .data = (const struct snd_usb_audio_quirk[]) { 3409 { 3410 .ifnum = 0, 3411 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3412 .data = &(const struct audioformat) { 3413 .formats = SNDRV_PCM_FMTBIT_S32_LE, 3414 .channels = 12, 3415 .iface = 0, 3416 .altsetting = 1, 3417 .altset_idx = 1, 3418 .endpoint = 0x05, 3419 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3420 USB_ENDPOINT_SYNC_ASYNC, 3421 .rates = SNDRV_PCM_RATE_44100, 3422 .rate_min = 44100, 3423 .rate_max = 44100, 3424 .nr_rates = 1, 3425 .rate_table = (unsigned int[]) { 44100 } 3426 } 3427 }, 3428 { 3429 .ifnum = 0, 3430 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3431 .data = &(const struct audioformat) { 3432 .formats = SNDRV_PCM_FMTBIT_S32_LE, 3433 .channels = 10, 3434 .iface = 0, 3435 .altsetting = 1, 3436 .altset_idx = 1, 3437 .endpoint = 0x86, 3438 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3439 USB_ENDPOINT_SYNC_ASYNC| 3440 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3441 .rates = SNDRV_PCM_RATE_44100, 3442 .rate_min = 44100, 3443 .rate_max = 44100, 3444 .nr_rates = 1, 3445 .rate_table = (unsigned int[]) { 44100 } 3446 } 3447 }, 3448 { 3449 .ifnum = -1 3450 } 3451 } 3452 } 3453 }, 3454 { 3455 /* 3456 * Pioneer DJ DJM-250MK2 3457 * PCM is 8 channels out @ 48 fixed (endpoint 0x01) 3458 * and 8 channels in @ 48 fixed (endpoint 0x82). 3459 * 3460 * Both playback and recording is working, even simultaneously. 3461 * 3462 * Playback channels could be mapped to: 3463 * - CH1 3464 * - CH2 3465 * - AUX 3466 * 3467 * Recording channels could be mapped to: 3468 * - Post CH1 Fader 3469 * - Post CH2 Fader 3470 * - Cross Fader A 3471 * - Cross Fader B 3472 * - MIC 3473 * - AUX 3474 * - REC OUT 3475 * 3476 * There is remaining problem with recording directly from PHONO/LINE. 3477 * If we map a channel to: 3478 * - CH1 Control Tone PHONO 3479 * - CH1 Control Tone LINE 3480 * - CH2 Control Tone PHONO 3481 * - CH2 Control Tone LINE 3482 * it is silent. 3483 * There is no signal even on other operating systems with official drivers. 3484 * The signal appears only when a supported application is started. 3485 * This needs to be investigated yet... 3486 * (there is quite a lot communication on the USB in both directions) 3487 * 3488 * In current version this mixer could be used for playback 3489 * and for recording from vinyls (through Post CH* Fader) 3490 * but not for DVS (Digital Vinyl Systems) like in Mixxx. 3491 */ 3492 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x0017), 3493 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3494 .ifnum = QUIRK_ANY_INTERFACE, 3495 .type = QUIRK_COMPOSITE, 3496 .data = (const struct snd_usb_audio_quirk[]) { 3497 { 3498 .ifnum = 0, 3499 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3500 .data = &(const struct audioformat) { 3501 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3502 .channels = 8, // outputs 3503 .iface = 0, 3504 .altsetting = 1, 3505 .altset_idx = 1, 3506 .endpoint = 0x01, 3507 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3508 USB_ENDPOINT_SYNC_ASYNC, 3509 .rates = SNDRV_PCM_RATE_48000, 3510 .rate_min = 48000, 3511 .rate_max = 48000, 3512 .nr_rates = 1, 3513 .rate_table = (unsigned int[]) { 48000 } 3514 } 3515 }, 3516 { 3517 .ifnum = 0, 3518 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3519 .data = &(const struct audioformat) { 3520 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3521 .channels = 8, // inputs 3522 .iface = 0, 3523 .altsetting = 1, 3524 .altset_idx = 1, 3525 .endpoint = 0x82, 3526 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3527 USB_ENDPOINT_SYNC_ASYNC| 3528 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3529 .rates = SNDRV_PCM_RATE_48000, 3530 .rate_min = 48000, 3531 .rate_max = 48000, 3532 .nr_rates = 1, 3533 .rate_table = (unsigned int[]) { 48000 } 3534 } 3535 }, 3536 { 3537 .ifnum = -1 3538 } 3539 } 3540 } 3541 }, 3542 { 3543 /* 3544 * PIONEER DJ DDJ-RB 3545 * PCM is 4 channels out, 2 dummy channels in @ 44.1 fixed 3546 * The feedback for the output is the dummy input. 3547 */ 3548 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000e), 3549 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3550 .ifnum = QUIRK_ANY_INTERFACE, 3551 .type = QUIRK_COMPOSITE, 3552 .data = (const struct snd_usb_audio_quirk[]) { 3553 { 3554 .ifnum = 0, 3555 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3556 .data = &(const struct audioformat) { 3557 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3558 .channels = 4, 3559 .iface = 0, 3560 .altsetting = 1, 3561 .altset_idx = 1, 3562 .endpoint = 0x01, 3563 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3564 USB_ENDPOINT_SYNC_ASYNC, 3565 .rates = SNDRV_PCM_RATE_44100, 3566 .rate_min = 44100, 3567 .rate_max = 44100, 3568 .nr_rates = 1, 3569 .rate_table = (unsigned int[]) { 44100 } 3570 } 3571 }, 3572 { 3573 .ifnum = 0, 3574 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3575 .data = &(const struct audioformat) { 3576 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3577 .channels = 2, 3578 .iface = 0, 3579 .altsetting = 1, 3580 .altset_idx = 1, 3581 .endpoint = 0x82, 3582 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3583 USB_ENDPOINT_SYNC_ASYNC| 3584 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3585 .rates = SNDRV_PCM_RATE_44100, 3586 .rate_min = 44100, 3587 .rate_max = 44100, 3588 .nr_rates = 1, 3589 .rate_table = (unsigned int[]) { 44100 } 3590 } 3591 }, 3592 { 3593 .ifnum = -1 3594 } 3595 } 3596 } 3597 }, 3598 3599 { 3600 /* 3601 * Pioneer DJ DJM-900NXS2 3602 * 10 channels playback & 12 channels capture @ 44.1/48/96kHz S24LE 3603 */ 3604 USB_DEVICE_VENDOR_SPEC(0x2b73, 0x000a), 3605 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3606 .ifnum = QUIRK_ANY_INTERFACE, 3607 .type = QUIRK_COMPOSITE, 3608 .data = (const struct snd_usb_audio_quirk[]) { 3609 { 3610 .ifnum = 0, 3611 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3612 .data = &(const struct audioformat) { 3613 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3614 .channels = 10, 3615 .iface = 0, 3616 .altsetting = 1, 3617 .altset_idx = 1, 3618 .endpoint = 0x01, 3619 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3620 USB_ENDPOINT_SYNC_ASYNC, 3621 .rates = SNDRV_PCM_RATE_44100| 3622 SNDRV_PCM_RATE_48000| 3623 SNDRV_PCM_RATE_96000, 3624 .rate_min = 44100, 3625 .rate_max = 96000, 3626 .nr_rates = 3, 3627 .rate_table = (unsigned int[]) { 3628 44100, 48000, 96000 3629 } 3630 } 3631 }, 3632 { 3633 .ifnum = 0, 3634 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3635 .data = &(const struct audioformat) { 3636 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 3637 .channels = 12, 3638 .iface = 0, 3639 .altsetting = 1, 3640 .altset_idx = 1, 3641 .endpoint = 0x82, 3642 .ep_attr = USB_ENDPOINT_XFER_ISOC| 3643 USB_ENDPOINT_SYNC_ASYNC| 3644 USB_ENDPOINT_USAGE_IMPLICIT_FB, 3645 .rates = SNDRV_PCM_RATE_44100| 3646 SNDRV_PCM_RATE_48000| 3647 SNDRV_PCM_RATE_96000, 3648 .rate_min = 44100, 3649 .rate_max = 96000, 3650 .nr_rates = 3, 3651 .rate_table = (unsigned int[]) { 3652 44100, 48000, 96000 3653 } 3654 } 3655 }, 3656 { 3657 .ifnum = -1 3658 } 3659 } 3660 } 3661 }, 3662 3663 /* 3664 * MacroSilicon MS2100/MS2106 based AV capture cards 3665 * 3666 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch. 3667 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if 3668 * they pretend to be 96kHz mono as a workaround for stereo being broken 3669 * by that... 3670 * 3671 * They also have an issue with initial stream alignment that causes the 3672 * channels to be swapped and out of phase, which is dealt with in quirks.c. 3673 */ 3674 { 3675 USB_AUDIO_DEVICE(0x534d, 0x0021), 3676 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3677 .vendor_name = "MacroSilicon", 3678 .product_name = "MS210x", 3679 .ifnum = QUIRK_ANY_INTERFACE, 3680 .type = QUIRK_COMPOSITE, 3681 .data = &(const struct snd_usb_audio_quirk[]) { 3682 { 3683 .ifnum = 2, 3684 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 3685 }, 3686 { 3687 .ifnum = 2, 3688 .type = QUIRK_AUDIO_STANDARD_MIXER, 3689 }, 3690 { 3691 .ifnum = 3, 3692 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3693 .data = &(const struct audioformat) { 3694 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3695 .channels = 2, 3696 .iface = 3, 3697 .altsetting = 1, 3698 .altset_idx = 1, 3699 .attributes = 0, 3700 .endpoint = 0x82, 3701 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3702 USB_ENDPOINT_SYNC_ASYNC, 3703 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3704 .rate_min = 48000, 3705 .rate_max = 48000, 3706 } 3707 }, 3708 { 3709 .ifnum = -1 3710 } 3711 } 3712 } 3713 }, 3714 3715 /* 3716 * MacroSilicon MS2109 based HDMI capture cards 3717 * 3718 * These claim 96kHz 1ch in the descriptors, but are actually 48kHz 2ch. 3719 * They also need QUIRK_AUDIO_ALIGN_TRANSFER, which makes one wonder if 3720 * they pretend to be 96kHz mono as a workaround for stereo being broken 3721 * by that... 3722 * 3723 * They also have an issue with initial stream alignment that causes the 3724 * channels to be swapped and out of phase, which is dealt with in quirks.c. 3725 */ 3726 { 3727 USB_AUDIO_DEVICE(0x534d, 0x2109), 3728 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3729 .vendor_name = "MacroSilicon", 3730 .product_name = "MS2109", 3731 .ifnum = QUIRK_ANY_INTERFACE, 3732 .type = QUIRK_COMPOSITE, 3733 .data = &(const struct snd_usb_audio_quirk[]) { 3734 { 3735 .ifnum = 2, 3736 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 3737 }, 3738 { 3739 .ifnum = 2, 3740 .type = QUIRK_AUDIO_STANDARD_MIXER, 3741 }, 3742 { 3743 .ifnum = 3, 3744 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 3745 .data = &(const struct audioformat) { 3746 .formats = SNDRV_PCM_FMTBIT_S16_LE, 3747 .channels = 2, 3748 .iface = 3, 3749 .altsetting = 1, 3750 .altset_idx = 1, 3751 .attributes = 0, 3752 .endpoint = 0x82, 3753 .ep_attr = USB_ENDPOINT_XFER_ISOC | 3754 USB_ENDPOINT_SYNC_ASYNC, 3755 .rates = SNDRV_PCM_RATE_CONTINUOUS, 3756 .rate_min = 48000, 3757 .rate_max = 48000, 3758 } 3759 }, 3760 { 3761 .ifnum = -1 3762 } 3763 } 3764 } 3765 }, 3766 { 3767 /* 3768 * Sennheiser GSP670 3769 * Change order of interfaces loaded 3770 */ 3771 USB_DEVICE(0x1395, 0x0300), 3772 .bInterfaceClass = USB_CLASS_PER_INTERFACE, 3773 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3774 .ifnum = QUIRK_ANY_INTERFACE, 3775 .type = QUIRK_COMPOSITE, 3776 .data = &(const struct snd_usb_audio_quirk[]) { 3777 // Communication 3778 { 3779 .ifnum = 3, 3780 .type = QUIRK_AUDIO_STANDARD_INTERFACE 3781 }, 3782 // Recording 3783 { 3784 .ifnum = 4, 3785 .type = QUIRK_AUDIO_STANDARD_INTERFACE 3786 }, 3787 // Main 3788 { 3789 .ifnum = 1, 3790 .type = QUIRK_AUDIO_STANDARD_INTERFACE 3791 }, 3792 { 3793 .ifnum = -1 3794 } 3795 } 3796 } 3797 }, 3798 3799 #undef USB_DEVICE_VENDOR_SPEC 3800 #undef USB_AUDIO_DEVICE 3801