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