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