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