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