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