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