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 /* BOSS ME-25 */ 1585 USB_DEVICE(0x0582, 0x0113), 1586 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1587 .ifnum = QUIRK_ANY_INTERFACE, 1588 .type = QUIRK_COMPOSITE, 1589 .data = (const struct snd_usb_audio_quirk[]) { 1590 { 1591 .ifnum = 0, 1592 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1593 }, 1594 { 1595 .ifnum = 1, 1596 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1597 }, 1598 { 1599 .ifnum = 2, 1600 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1601 .data = & (const struct snd_usb_midi_endpoint_info) { 1602 .out_cables = 0x0001, 1603 .in_cables = 0x0001 1604 } 1605 }, 1606 { 1607 .ifnum = -1 1608 } 1609 } 1610 } 1611 }, 1612 { 1613 /* only 44.1 kHz works at the moment */ 1614 USB_DEVICE(0x0582, 0x0120), 1615 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1616 /* .vendor_name = "Roland", */ 1617 /* .product_name = "OCTO-CAPTURE", */ 1618 .ifnum = QUIRK_ANY_INTERFACE, 1619 .type = QUIRK_COMPOSITE, 1620 .data = (const struct snd_usb_audio_quirk[]) { 1621 { 1622 .ifnum = 0, 1623 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1624 .data = & (const struct audioformat) { 1625 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1626 .channels = 10, 1627 .iface = 0, 1628 .altsetting = 1, 1629 .altset_idx = 1, 1630 .endpoint = 0x05, 1631 .ep_attr = 0x05, 1632 .rates = SNDRV_PCM_RATE_44100, 1633 .rate_min = 44100, 1634 .rate_max = 44100, 1635 .nr_rates = 1, 1636 .rate_table = (unsigned int[]) { 44100 } 1637 } 1638 }, 1639 { 1640 .ifnum = 1, 1641 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1642 .data = & (const struct audioformat) { 1643 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1644 .channels = 12, 1645 .iface = 1, 1646 .altsetting = 1, 1647 .altset_idx = 1, 1648 .endpoint = 0x85, 1649 .ep_attr = 0x25, 1650 .rates = SNDRV_PCM_RATE_44100, 1651 .rate_min = 44100, 1652 .rate_max = 44100, 1653 .nr_rates = 1, 1654 .rate_table = (unsigned int[]) { 44100 } 1655 } 1656 }, 1657 { 1658 .ifnum = 2, 1659 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1660 .data = & (const struct snd_usb_midi_endpoint_info) { 1661 .out_cables = 0x0001, 1662 .in_cables = 0x0001 1663 } 1664 }, 1665 { 1666 .ifnum = 3, 1667 .type = QUIRK_IGNORE_INTERFACE 1668 }, 1669 { 1670 .ifnum = 4, 1671 .type = QUIRK_IGNORE_INTERFACE 1672 }, 1673 { 1674 .ifnum = -1 1675 } 1676 } 1677 } 1678 }, 1679 { 1680 /* only 44.1 kHz works at the moment */ 1681 USB_DEVICE(0x0582, 0x012f), 1682 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1683 /* .vendor_name = "Roland", */ 1684 /* .product_name = "QUAD-CAPTURE", */ 1685 .ifnum = QUIRK_ANY_INTERFACE, 1686 .type = QUIRK_COMPOSITE, 1687 .data = (const struct snd_usb_audio_quirk[]) { 1688 { 1689 .ifnum = 0, 1690 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1691 .data = & (const struct audioformat) { 1692 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1693 .channels = 4, 1694 .iface = 0, 1695 .altsetting = 1, 1696 .altset_idx = 1, 1697 .endpoint = 0x05, 1698 .ep_attr = 0x05, 1699 .rates = SNDRV_PCM_RATE_44100, 1700 .rate_min = 44100, 1701 .rate_max = 44100, 1702 .nr_rates = 1, 1703 .rate_table = (unsigned int[]) { 44100 } 1704 } 1705 }, 1706 { 1707 .ifnum = 1, 1708 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 1709 .data = & (const struct audioformat) { 1710 .formats = SNDRV_PCM_FMTBIT_S32_LE, 1711 .channels = 6, 1712 .iface = 1, 1713 .altsetting = 1, 1714 .altset_idx = 1, 1715 .endpoint = 0x85, 1716 .ep_attr = 0x25, 1717 .rates = SNDRV_PCM_RATE_44100, 1718 .rate_min = 44100, 1719 .rate_max = 44100, 1720 .nr_rates = 1, 1721 .rate_table = (unsigned int[]) { 44100 } 1722 } 1723 }, 1724 { 1725 .ifnum = 2, 1726 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1727 .data = & (const struct snd_usb_midi_endpoint_info) { 1728 .out_cables = 0x0001, 1729 .in_cables = 0x0001 1730 } 1731 }, 1732 { 1733 .ifnum = 3, 1734 .type = QUIRK_IGNORE_INTERFACE 1735 }, 1736 { 1737 .ifnum = 4, 1738 .type = QUIRK_IGNORE_INTERFACE 1739 }, 1740 { 1741 .ifnum = -1 1742 } 1743 } 1744 } 1745 }, 1746 /* this catches most recent vendor-specific Roland devices */ 1747 { 1748 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 1749 USB_DEVICE_ID_MATCH_INT_CLASS, 1750 .idVendor = 0x0582, 1751 .bInterfaceClass = USB_CLASS_VENDOR_SPEC, 1752 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 1753 .ifnum = QUIRK_ANY_INTERFACE, 1754 .type = QUIRK_AUTODETECT 1755 } 1756 }, 1757 1758 /* Guillemot devices */ 1759 { 1760 /* 1761 * This is for the "Windows Edition" where the external MIDI ports are 1762 * the only MIDI ports; the control data is reported through HID 1763 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1764 * compliant USB MIDI ports for external MIDI and controls. 1765 */ 1766 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1767 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1768 .vendor_name = "Hercules", 1769 .product_name = "DJ Console (WE)", 1770 .ifnum = 4, 1771 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1772 .data = & (const struct snd_usb_midi_endpoint_info) { 1773 .out_cables = 0x0001, 1774 .in_cables = 0x0001 1775 } 1776 } 1777 }, 1778 1779 /* Midiman/M-Audio devices */ 1780 { 1781 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1782 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1783 .vendor_name = "M-Audio", 1784 .product_name = "MidiSport 2x2", 1785 .ifnum = QUIRK_ANY_INTERFACE, 1786 .type = QUIRK_MIDI_MIDIMAN, 1787 .data = & (const struct snd_usb_midi_endpoint_info) { 1788 .out_cables = 0x0003, 1789 .in_cables = 0x0003 1790 } 1791 } 1792 }, 1793 { 1794 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1795 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1796 .vendor_name = "M-Audio", 1797 .product_name = "MidiSport 1x1", 1798 .ifnum = QUIRK_ANY_INTERFACE, 1799 .type = QUIRK_MIDI_MIDIMAN, 1800 .data = & (const struct snd_usb_midi_endpoint_info) { 1801 .out_cables = 0x0001, 1802 .in_cables = 0x0001 1803 } 1804 } 1805 }, 1806 { 1807 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1808 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1809 .vendor_name = "M-Audio", 1810 .product_name = "Keystation", 1811 .ifnum = QUIRK_ANY_INTERFACE, 1812 .type = QUIRK_MIDI_MIDIMAN, 1813 .data = & (const struct snd_usb_midi_endpoint_info) { 1814 .out_cables = 0x0001, 1815 .in_cables = 0x0001 1816 } 1817 } 1818 }, 1819 { 1820 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1821 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1822 .vendor_name = "M-Audio", 1823 .product_name = "MidiSport 4x4", 1824 .ifnum = QUIRK_ANY_INTERFACE, 1825 .type = QUIRK_MIDI_MIDIMAN, 1826 .data = & (const struct snd_usb_midi_endpoint_info) { 1827 .out_cables = 0x000f, 1828 .in_cables = 0x000f 1829 } 1830 } 1831 }, 1832 { 1833 /* 1834 * For hardware revision 1.05; in the later revisions (1.10 and 1835 * 1.21), 0x1031 is the ID for the device without firmware. 1836 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1837 */ 1838 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1839 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1840 .vendor_name = "M-Audio", 1841 .product_name = "MidiSport 8x8", 1842 .ifnum = QUIRK_ANY_INTERFACE, 1843 .type = QUIRK_MIDI_MIDIMAN, 1844 .data = & (const struct snd_usb_midi_endpoint_info) { 1845 .out_cables = 0x01ff, 1846 .in_cables = 0x01ff 1847 } 1848 } 1849 }, 1850 { 1851 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1852 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1853 .vendor_name = "M-Audio", 1854 .product_name = "MidiSport 8x8", 1855 .ifnum = QUIRK_ANY_INTERFACE, 1856 .type = QUIRK_MIDI_MIDIMAN, 1857 .data = & (const struct snd_usb_midi_endpoint_info) { 1858 .out_cables = 0x01ff, 1859 .in_cables = 0x01ff 1860 } 1861 } 1862 }, 1863 { 1864 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1865 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1866 .vendor_name = "M-Audio", 1867 .product_name = "MidiSport 2x4", 1868 .ifnum = QUIRK_ANY_INTERFACE, 1869 .type = QUIRK_MIDI_MIDIMAN, 1870 .data = & (const struct snd_usb_midi_endpoint_info) { 1871 .out_cables = 0x000f, 1872 .in_cables = 0x0003 1873 } 1874 } 1875 }, 1876 { 1877 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1878 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1879 .vendor_name = "M-Audio", 1880 .product_name = "Quattro", 1881 .ifnum = QUIRK_ANY_INTERFACE, 1882 .type = QUIRK_COMPOSITE, 1883 .data = & (const struct snd_usb_audio_quirk[]) { 1884 /* 1885 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1886 * and share endpoints with the other interfaces. 1887 * Ignore them. The other interfaces can do 24 bits, 1888 * but captured samples are big-endian (see usbaudio.c). 1889 */ 1890 { 1891 .ifnum = 0, 1892 .type = QUIRK_IGNORE_INTERFACE 1893 }, 1894 { 1895 .ifnum = 1, 1896 .type = QUIRK_IGNORE_INTERFACE 1897 }, 1898 { 1899 .ifnum = 2, 1900 .type = QUIRK_IGNORE_INTERFACE 1901 }, 1902 { 1903 .ifnum = 3, 1904 .type = QUIRK_IGNORE_INTERFACE 1905 }, 1906 { 1907 .ifnum = 4, 1908 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1909 }, 1910 { 1911 .ifnum = 5, 1912 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1913 }, 1914 { 1915 .ifnum = 6, 1916 .type = QUIRK_IGNORE_INTERFACE 1917 }, 1918 { 1919 .ifnum = 7, 1920 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1921 }, 1922 { 1923 .ifnum = 8, 1924 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1925 }, 1926 { 1927 .ifnum = 9, 1928 .type = QUIRK_MIDI_MIDIMAN, 1929 .data = & (const struct snd_usb_midi_endpoint_info) { 1930 .out_cables = 0x0001, 1931 .in_cables = 0x0001 1932 } 1933 }, 1934 { 1935 .ifnum = -1 1936 } 1937 } 1938 } 1939 }, 1940 { 1941 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 1942 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1943 .vendor_name = "M-Audio", 1944 .product_name = "AudioPhile", 1945 .ifnum = 6, 1946 .type = QUIRK_MIDI_MIDIMAN, 1947 .data = & (const struct snd_usb_midi_endpoint_info) { 1948 .out_cables = 0x0001, 1949 .in_cables = 0x0001 1950 } 1951 } 1952 }, 1953 { 1954 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 1955 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1956 .vendor_name = "M-Audio", 1957 .product_name = "Ozone", 1958 .ifnum = 3, 1959 .type = QUIRK_MIDI_MIDIMAN, 1960 .data = & (const struct snd_usb_midi_endpoint_info) { 1961 .out_cables = 0x0001, 1962 .in_cables = 0x0001 1963 } 1964 } 1965 }, 1966 { 1967 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 1968 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1969 .vendor_name = "M-Audio", 1970 .product_name = "OmniStudio", 1971 .ifnum = QUIRK_ANY_INTERFACE, 1972 .type = QUIRK_COMPOSITE, 1973 .data = & (const struct snd_usb_audio_quirk[]) { 1974 { 1975 .ifnum = 0, 1976 .type = QUIRK_IGNORE_INTERFACE 1977 }, 1978 { 1979 .ifnum = 1, 1980 .type = QUIRK_IGNORE_INTERFACE 1981 }, 1982 { 1983 .ifnum = 2, 1984 .type = QUIRK_IGNORE_INTERFACE 1985 }, 1986 { 1987 .ifnum = 3, 1988 .type = QUIRK_IGNORE_INTERFACE 1989 }, 1990 { 1991 .ifnum = 4, 1992 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1993 }, 1994 { 1995 .ifnum = 5, 1996 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1997 }, 1998 { 1999 .ifnum = 6, 2000 .type = QUIRK_IGNORE_INTERFACE 2001 }, 2002 { 2003 .ifnum = 7, 2004 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2005 }, 2006 { 2007 .ifnum = 8, 2008 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2009 }, 2010 { 2011 .ifnum = 9, 2012 .type = QUIRK_MIDI_MIDIMAN, 2013 .data = & (const struct snd_usb_midi_endpoint_info) { 2014 .out_cables = 0x0001, 2015 .in_cables = 0x0001 2016 } 2017 }, 2018 { 2019 .ifnum = -1 2020 } 2021 } 2022 } 2023 }, 2024 { 2025 USB_DEVICE(0x0763, 0x2019), 2026 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2027 /* .vendor_name = "M-Audio", */ 2028 /* .product_name = "Ozone Academic", */ 2029 .ifnum = QUIRK_ANY_INTERFACE, 2030 .type = QUIRK_COMPOSITE, 2031 .data = & (const struct snd_usb_audio_quirk[]) { 2032 { 2033 .ifnum = 0, 2034 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2035 }, 2036 { 2037 .ifnum = 1, 2038 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2039 }, 2040 { 2041 .ifnum = 2, 2042 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2043 }, 2044 { 2045 .ifnum = 3, 2046 .type = QUIRK_MIDI_MIDIMAN, 2047 .data = & (const struct snd_usb_midi_endpoint_info) { 2048 .out_cables = 0x0001, 2049 .in_cables = 0x0001 2050 } 2051 }, 2052 { 2053 .ifnum = -1 2054 } 2055 } 2056 } 2057 }, 2058 { 2059 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030), 2060 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2061 /* .vendor_name = "M-Audio", */ 2062 /* .product_name = "Fast Track C400", */ 2063 .ifnum = QUIRK_ANY_INTERFACE, 2064 .type = QUIRK_COMPOSITE, 2065 .data = &(const struct snd_usb_audio_quirk[]) { 2066 { 2067 .ifnum = 1, 2068 .type = QUIRK_AUDIO_STANDARD_MIXER, 2069 }, 2070 /* Playback */ 2071 { 2072 .ifnum = 2, 2073 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2074 .data = &(const struct audioformat) { 2075 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2076 .channels = 6, 2077 .iface = 2, 2078 .altsetting = 1, 2079 .altset_idx = 1, 2080 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2081 .endpoint = 0x01, 2082 .ep_attr = 0x09, 2083 .rates = SNDRV_PCM_RATE_44100 | 2084 SNDRV_PCM_RATE_48000 | 2085 SNDRV_PCM_RATE_88200 | 2086 SNDRV_PCM_RATE_96000, 2087 .rate_min = 44100, 2088 .rate_max = 96000, 2089 .nr_rates = 4, 2090 .rate_table = (unsigned int[]) { 2091 44100, 48000, 88200, 96000 2092 }, 2093 .clock = 0x80, 2094 } 2095 }, 2096 /* Capture */ 2097 { 2098 .ifnum = 3, 2099 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2100 .data = &(const struct audioformat) { 2101 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2102 .channels = 4, 2103 .iface = 3, 2104 .altsetting = 1, 2105 .altset_idx = 1, 2106 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2107 .endpoint = 0x81, 2108 .ep_attr = 0x05, 2109 .rates = SNDRV_PCM_RATE_44100 | 2110 SNDRV_PCM_RATE_48000 | 2111 SNDRV_PCM_RATE_88200 | 2112 SNDRV_PCM_RATE_96000, 2113 .rate_min = 44100, 2114 .rate_max = 96000, 2115 .nr_rates = 4, 2116 .rate_table = (unsigned int[]) { 2117 44100, 48000, 88200, 96000 2118 }, 2119 .clock = 0x80, 2120 } 2121 }, 2122 /* MIDI */ 2123 { 2124 .ifnum = -1 /* Interface = 4 */ 2125 } 2126 } 2127 } 2128 }, 2129 { 2130 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031), 2131 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2132 /* .vendor_name = "M-Audio", */ 2133 /* .product_name = "Fast Track C600", */ 2134 .ifnum = QUIRK_ANY_INTERFACE, 2135 .type = QUIRK_COMPOSITE, 2136 .data = &(const struct snd_usb_audio_quirk[]) { 2137 { 2138 .ifnum = 1, 2139 .type = QUIRK_AUDIO_STANDARD_MIXER, 2140 }, 2141 /* Playback */ 2142 { 2143 .ifnum = 2, 2144 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2145 .data = &(const struct audioformat) { 2146 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2147 .channels = 8, 2148 .iface = 2, 2149 .altsetting = 1, 2150 .altset_idx = 1, 2151 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2152 .endpoint = 0x01, 2153 .ep_attr = 0x09, 2154 .rates = SNDRV_PCM_RATE_44100 | 2155 SNDRV_PCM_RATE_48000 | 2156 SNDRV_PCM_RATE_88200 | 2157 SNDRV_PCM_RATE_96000, 2158 .rate_min = 44100, 2159 .rate_max = 96000, 2160 .nr_rates = 4, 2161 .rate_table = (unsigned int[]) { 2162 44100, 48000, 88200, 96000 2163 }, 2164 .clock = 0x80, 2165 } 2166 }, 2167 /* Capture */ 2168 { 2169 .ifnum = 3, 2170 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2171 .data = &(const struct audioformat) { 2172 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2173 .channels = 6, 2174 .iface = 3, 2175 .altsetting = 1, 2176 .altset_idx = 1, 2177 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2178 .endpoint = 0x81, 2179 .ep_attr = 0x05, 2180 .rates = SNDRV_PCM_RATE_44100 | 2181 SNDRV_PCM_RATE_48000 | 2182 SNDRV_PCM_RATE_88200 | 2183 SNDRV_PCM_RATE_96000, 2184 .rate_min = 44100, 2185 .rate_max = 96000, 2186 .nr_rates = 4, 2187 .rate_table = (unsigned int[]) { 2188 44100, 48000, 88200, 96000 2189 }, 2190 .clock = 0x80, 2191 } 2192 }, 2193 /* MIDI */ 2194 { 2195 .ifnum = -1 /* Interface = 4 */ 2196 } 2197 } 2198 } 2199 }, 2200 { 2201 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080), 2202 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2203 /* .vendor_name = "M-Audio", */ 2204 /* .product_name = "Fast Track Ultra", */ 2205 .ifnum = QUIRK_ANY_INTERFACE, 2206 .type = QUIRK_COMPOSITE, 2207 .data = & (const struct snd_usb_audio_quirk[]) { 2208 { 2209 .ifnum = 0, 2210 .type = QUIRK_AUDIO_STANDARD_MIXER, 2211 }, 2212 { 2213 .ifnum = 1, 2214 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2215 .data = & (const struct audioformat) { 2216 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2217 .channels = 8, 2218 .iface = 1, 2219 .altsetting = 1, 2220 .altset_idx = 1, 2221 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2222 .endpoint = 0x01, 2223 .ep_attr = 0x09, 2224 .rates = SNDRV_PCM_RATE_44100 | 2225 SNDRV_PCM_RATE_48000 | 2226 SNDRV_PCM_RATE_88200 | 2227 SNDRV_PCM_RATE_96000, 2228 .rate_min = 44100, 2229 .rate_max = 96000, 2230 .nr_rates = 4, 2231 .rate_table = (unsigned int[]) { 2232 44100, 48000, 88200, 96000 2233 } 2234 } 2235 }, 2236 { 2237 .ifnum = 2, 2238 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2239 .data = & (const struct audioformat) { 2240 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2241 .channels = 8, 2242 .iface = 2, 2243 .altsetting = 1, 2244 .altset_idx = 1, 2245 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2246 .endpoint = 0x81, 2247 .ep_attr = 0x05, 2248 .rates = SNDRV_PCM_RATE_44100 | 2249 SNDRV_PCM_RATE_48000 | 2250 SNDRV_PCM_RATE_88200 | 2251 SNDRV_PCM_RATE_96000, 2252 .rate_min = 44100, 2253 .rate_max = 96000, 2254 .nr_rates = 4, 2255 .rate_table = (unsigned int[]) { 2256 44100, 48000, 88200, 96000 2257 } 2258 } 2259 }, 2260 /* interface 3 (MIDI) is standard compliant */ 2261 { 2262 .ifnum = -1 2263 } 2264 } 2265 } 2266 }, 2267 { 2268 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2269 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2270 /* .vendor_name = "M-Audio", */ 2271 /* .product_name = "Fast Track Ultra 8R", */ 2272 .ifnum = QUIRK_ANY_INTERFACE, 2273 .type = QUIRK_COMPOSITE, 2274 .data = & (const struct snd_usb_audio_quirk[]) { 2275 { 2276 .ifnum = 0, 2277 .type = QUIRK_AUDIO_STANDARD_MIXER, 2278 }, 2279 { 2280 .ifnum = 1, 2281 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2282 .data = & (const struct audioformat) { 2283 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2284 .channels = 8, 2285 .iface = 1, 2286 .altsetting = 1, 2287 .altset_idx = 1, 2288 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2289 .endpoint = 0x01, 2290 .ep_attr = 0x09, 2291 .rates = SNDRV_PCM_RATE_44100 | 2292 SNDRV_PCM_RATE_48000 | 2293 SNDRV_PCM_RATE_88200 | 2294 SNDRV_PCM_RATE_96000, 2295 .rate_min = 44100, 2296 .rate_max = 96000, 2297 .nr_rates = 4, 2298 .rate_table = (unsigned int[]) { 2299 44100, 48000, 88200, 96000 2300 } 2301 } 2302 }, 2303 { 2304 .ifnum = 2, 2305 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2306 .data = & (const struct audioformat) { 2307 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2308 .channels = 8, 2309 .iface = 2, 2310 .altsetting = 1, 2311 .altset_idx = 1, 2312 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2313 .endpoint = 0x81, 2314 .ep_attr = 0x05, 2315 .rates = SNDRV_PCM_RATE_44100 | 2316 SNDRV_PCM_RATE_48000 | 2317 SNDRV_PCM_RATE_88200 | 2318 SNDRV_PCM_RATE_96000, 2319 .rate_min = 44100, 2320 .rate_max = 96000, 2321 .nr_rates = 4, 2322 .rate_table = (unsigned int[]) { 2323 44100, 48000, 88200, 96000 2324 } 2325 } 2326 }, 2327 /* interface 3 (MIDI) is standard compliant */ 2328 { 2329 .ifnum = -1 2330 } 2331 } 2332 } 2333 }, 2334 2335 /* Casio devices */ 2336 { 2337 USB_DEVICE(0x07cf, 0x6801), 2338 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2339 .vendor_name = "Casio", 2340 .product_name = "PL-40R", 2341 .ifnum = 0, 2342 .type = QUIRK_MIDI_YAMAHA 2343 } 2344 }, 2345 { 2346 /* this ID is used by several devices without a product ID */ 2347 USB_DEVICE(0x07cf, 0x6802), 2348 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2349 .vendor_name = "Casio", 2350 .product_name = "Keyboard", 2351 .ifnum = 0, 2352 .type = QUIRK_MIDI_YAMAHA 2353 } 2354 }, 2355 2356 /* Mark of the Unicorn devices */ 2357 { 2358 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2359 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2360 USB_DEVICE_ID_MATCH_PRODUCT | 2361 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2362 .idVendor = 0x07fd, 2363 .idProduct = 0x0001, 2364 .bDeviceSubClass = 2, 2365 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2366 .vendor_name = "MOTU", 2367 .product_name = "Fastlane", 2368 .ifnum = QUIRK_ANY_INTERFACE, 2369 .type = QUIRK_COMPOSITE, 2370 .data = & (const struct snd_usb_audio_quirk[]) { 2371 { 2372 .ifnum = 0, 2373 .type = QUIRK_MIDI_RAW_BYTES 2374 }, 2375 { 2376 .ifnum = 1, 2377 .type = QUIRK_IGNORE_INTERFACE 2378 }, 2379 { 2380 .ifnum = -1 2381 } 2382 } 2383 } 2384 }, 2385 2386 /* Emagic devices */ 2387 { 2388 USB_DEVICE(0x086a, 0x0001), 2389 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2390 .vendor_name = "Emagic", 2391 /* .product_name = "Unitor8", */ 2392 .ifnum = 2, 2393 .type = QUIRK_MIDI_EMAGIC, 2394 .data = & (const struct snd_usb_midi_endpoint_info) { 2395 .out_cables = 0x80ff, 2396 .in_cables = 0x80ff 2397 } 2398 } 2399 }, 2400 { 2401 USB_DEVICE(0x086a, 0x0002), 2402 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2403 .vendor_name = "Emagic", 2404 /* .product_name = "AMT8", */ 2405 .ifnum = 2, 2406 .type = QUIRK_MIDI_EMAGIC, 2407 .data = & (const struct snd_usb_midi_endpoint_info) { 2408 .out_cables = 0x80ff, 2409 .in_cables = 0x80ff 2410 } 2411 } 2412 }, 2413 { 2414 USB_DEVICE(0x086a, 0x0003), 2415 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2416 .vendor_name = "Emagic", 2417 /* .product_name = "MT4", */ 2418 .ifnum = 2, 2419 .type = QUIRK_MIDI_EMAGIC, 2420 .data = & (const struct snd_usb_midi_endpoint_info) { 2421 .out_cables = 0x800f, 2422 .in_cables = 0x8003 2423 } 2424 } 2425 }, 2426 2427 /* KORG devices */ 2428 { 2429 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2430 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2431 .vendor_name = "KORG, Inc.", 2432 /* .product_name = "PANDORA PX5D", */ 2433 .ifnum = 3, 2434 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2435 } 2436 }, 2437 2438 { 2439 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201), 2440 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2441 .vendor_name = "KORG, Inc.", 2442 /* .product_name = "ToneLab ST", */ 2443 .ifnum = 3, 2444 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2445 } 2446 }, 2447 2448 /* AKAI devices */ 2449 { 2450 USB_DEVICE(0x09e8, 0x0062), 2451 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2452 .vendor_name = "AKAI", 2453 .product_name = "MPD16", 2454 .ifnum = 0, 2455 .type = QUIRK_MIDI_AKAI, 2456 } 2457 }, 2458 2459 /* TerraTec devices */ 2460 { 2461 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2462 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2463 .vendor_name = "TerraTec", 2464 .product_name = "PHASE 26", 2465 .ifnum = 3, 2466 .type = QUIRK_MIDI_STANDARD_INTERFACE 2467 } 2468 }, 2469 { 2470 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2471 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2472 .vendor_name = "TerraTec", 2473 .product_name = "PHASE 26", 2474 .ifnum = 3, 2475 .type = QUIRK_MIDI_STANDARD_INTERFACE 2476 } 2477 }, 2478 { 2479 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2480 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2481 .vendor_name = "TerraTec", 2482 .product_name = "PHASE 26", 2483 .ifnum = 3, 2484 .type = QUIRK_MIDI_STANDARD_INTERFACE 2485 } 2486 }, 2487 { 2488 USB_DEVICE(0x0ccd, 0x0028), 2489 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2490 .vendor_name = "TerraTec", 2491 .product_name = "Aureon5.1MkII", 2492 .ifnum = QUIRK_NO_INTERFACE 2493 } 2494 }, 2495 { 2496 USB_DEVICE(0x0ccd, 0x0035), 2497 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2498 .vendor_name = "Miditech", 2499 .product_name = "Play'n Roll", 2500 .ifnum = 0, 2501 .type = QUIRK_MIDI_CME 2502 } 2503 }, 2504 2505 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ 2506 { 2507 USB_DEVICE(0x103d, 0x0100), 2508 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2509 .vendor_name = "Stanton", 2510 .product_name = "ScratchAmp", 2511 .ifnum = QUIRK_NO_INTERFACE 2512 } 2513 }, 2514 { 2515 USB_DEVICE(0x103d, 0x0101), 2516 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2517 .vendor_name = "Stanton", 2518 .product_name = "ScratchAmp", 2519 .ifnum = QUIRK_NO_INTERFACE 2520 } 2521 }, 2522 2523 /* Novation EMS devices */ 2524 { 2525 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2526 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2527 .vendor_name = "Novation", 2528 .product_name = "ReMOTE Audio/XStation", 2529 .ifnum = 4, 2530 .type = QUIRK_MIDI_NOVATION 2531 } 2532 }, 2533 { 2534 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2535 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2536 .vendor_name = "Novation", 2537 .product_name = "Speedio", 2538 .ifnum = 3, 2539 .type = QUIRK_MIDI_NOVATION 2540 } 2541 }, 2542 { 2543 USB_DEVICE(0x1235, 0x000e), 2544 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2545 /* .vendor_name = "Novation", */ 2546 /* .product_name = "Launchpad", */ 2547 .ifnum = 0, 2548 .type = QUIRK_MIDI_RAW_BYTES 2549 } 2550 }, 2551 { 2552 USB_DEVICE(0x1235, 0x0010), 2553 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2554 .vendor_name = "Focusrite", 2555 .product_name = "Saffire 6 USB", 2556 .ifnum = QUIRK_ANY_INTERFACE, 2557 .type = QUIRK_COMPOSITE, 2558 .data = (const struct snd_usb_audio_quirk[]) { 2559 { 2560 .ifnum = 0, 2561 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2562 .data = &(const struct audioformat) { 2563 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2564 .channels = 4, 2565 .iface = 0, 2566 .altsetting = 1, 2567 .altset_idx = 1, 2568 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2569 .endpoint = 0x01, 2570 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2571 .rates = SNDRV_PCM_RATE_44100 | 2572 SNDRV_PCM_RATE_48000, 2573 .rate_min = 44100, 2574 .rate_max = 48000, 2575 .nr_rates = 2, 2576 .rate_table = (unsigned int[]) { 2577 44100, 48000 2578 } 2579 } 2580 }, 2581 { 2582 .ifnum = 1, 2583 .type = QUIRK_MIDI_RAW_BYTES 2584 }, 2585 { 2586 .ifnum = -1 2587 } 2588 } 2589 } 2590 }, 2591 { 2592 USB_DEVICE(0x1235, 0x0018), 2593 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2594 .vendor_name = "Novation", 2595 .product_name = "Twitch", 2596 .ifnum = QUIRK_ANY_INTERFACE, 2597 .type = QUIRK_COMPOSITE, 2598 .data = (const struct snd_usb_audio_quirk[]) { 2599 { 2600 .ifnum = 0, 2601 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2602 .data = & (const struct audioformat) { 2603 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2604 .channels = 4, 2605 .iface = 0, 2606 .altsetting = 1, 2607 .altset_idx = 1, 2608 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2609 .endpoint = 0x01, 2610 .ep_attr = USB_ENDPOINT_XFER_ISOC, 2611 .rates = SNDRV_PCM_RATE_44100 | 2612 SNDRV_PCM_RATE_48000, 2613 .rate_min = 44100, 2614 .rate_max = 48000, 2615 .nr_rates = 2, 2616 .rate_table = (unsigned int[]) { 2617 44100, 48000 2618 } 2619 } 2620 }, 2621 { 2622 .ifnum = 1, 2623 .type = QUIRK_MIDI_RAW_BYTES 2624 }, 2625 { 2626 .ifnum = -1 2627 } 2628 } 2629 } 2630 }, 2631 { 2632 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2633 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2634 .vendor_name = "Novation", 2635 .product_name = "ReMOTE25", 2636 .ifnum = 0, 2637 .type = QUIRK_MIDI_NOVATION 2638 } 2639 }, 2640 { 2641 /* 2642 * Focusrite Scarlett 18i6 2643 * 2644 * Avoid mixer creation, which otherwise fails because some of 2645 * the interface descriptor subtypes for interface 0 are 2646 * unknown. That should be fixed or worked-around but this at 2647 * least allows the device to be used successfully with a DAW 2648 * and an external mixer. See comments below about other 2649 * ignored interfaces. 2650 */ 2651 USB_DEVICE(0x1235, 0x8004), 2652 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2653 .vendor_name = "Focusrite", 2654 .product_name = "Scarlett 18i6", 2655 .ifnum = QUIRK_ANY_INTERFACE, 2656 .type = QUIRK_COMPOSITE, 2657 .data = & (const struct snd_usb_audio_quirk[]) { 2658 { 2659 /* InterfaceSubClass 1 (Control Device) */ 2660 .ifnum = 0, 2661 .type = QUIRK_IGNORE_INTERFACE 2662 }, 2663 { 2664 .ifnum = 1, 2665 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2666 }, 2667 { 2668 .ifnum = 2, 2669 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2670 }, 2671 { 2672 /* InterfaceSubClass 1 (Control Device) */ 2673 .ifnum = 3, 2674 .type = QUIRK_IGNORE_INTERFACE 2675 }, 2676 { 2677 .ifnum = 4, 2678 .type = QUIRK_MIDI_STANDARD_INTERFACE 2679 }, 2680 { 2681 /* InterfaceSubClass 1 (Device Firmware Update) */ 2682 .ifnum = 5, 2683 .type = QUIRK_IGNORE_INTERFACE 2684 }, 2685 { 2686 .ifnum = -1 2687 } 2688 } 2689 } 2690 }, 2691 2692 /* Access Music devices */ 2693 { 2694 /* VirusTI Desktop */ 2695 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2696 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2697 .ifnum = QUIRK_ANY_INTERFACE, 2698 .type = QUIRK_COMPOSITE, 2699 .data = &(const struct snd_usb_audio_quirk[]) { 2700 { 2701 .ifnum = 3, 2702 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2703 .data = &(const struct snd_usb_midi_endpoint_info) { 2704 .out_cables = 0x0003, 2705 .in_cables = 0x0003 2706 } 2707 }, 2708 { 2709 .ifnum = 4, 2710 .type = QUIRK_IGNORE_INTERFACE 2711 }, 2712 { 2713 .ifnum = -1 2714 } 2715 } 2716 } 2717 }, 2718 2719 /* */ 2720 { 2721 /* aka. Serato Scratch Live DJ Box */ 2722 USB_DEVICE(0x13e5, 0x0001), 2723 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2724 .vendor_name = "Rane", 2725 .product_name = "SL-1", 2726 .ifnum = QUIRK_NO_INTERFACE 2727 } 2728 }, 2729 2730 /* Native Instruments MK2 series */ 2731 { 2732 /* Komplete Audio 6 */ 2733 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2734 .idVendor = 0x17cc, 2735 .idProduct = 0x1000, 2736 }, 2737 { 2738 /* Traktor Audio 6 */ 2739 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2740 .idVendor = 0x17cc, 2741 .idProduct = 0x1010, 2742 }, 2743 { 2744 /* Traktor Audio 10 */ 2745 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2746 .idVendor = 0x17cc, 2747 .idProduct = 0x1020, 2748 }, 2749 2750 /* KeithMcMillen Stringport */ 2751 { 2752 USB_DEVICE(0x1f38, 0x0001), 2753 .bInterfaceClass = USB_CLASS_AUDIO, 2754 }, 2755 2756 /* Miditech devices */ 2757 { 2758 USB_DEVICE(0x4752, 0x0011), 2759 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2760 .vendor_name = "Miditech", 2761 .product_name = "Midistart-2", 2762 .ifnum = 0, 2763 .type = QUIRK_MIDI_CME 2764 } 2765 }, 2766 2767 /* Central Music devices */ 2768 { 2769 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2770 USB_DEVICE(0x7104, 0x2202), 2771 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2772 .ifnum = 0, 2773 .type = QUIRK_MIDI_CME 2774 } 2775 }, 2776 2777 /* Hauppauge HVR-950Q and HVR-850 */ 2778 { 2779 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200), 2780 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2781 USB_DEVICE_ID_MATCH_INT_CLASS | 2782 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2783 .bInterfaceClass = USB_CLASS_AUDIO, 2784 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2785 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2786 .vendor_name = "Hauppauge", 2787 .product_name = "HVR-950Q", 2788 .ifnum = QUIRK_ANY_INTERFACE, 2789 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2790 } 2791 }, 2792 { 2793 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210), 2794 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2795 USB_DEVICE_ID_MATCH_INT_CLASS | 2796 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2797 .bInterfaceClass = USB_CLASS_AUDIO, 2798 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2799 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2800 .vendor_name = "Hauppauge", 2801 .product_name = "HVR-950Q", 2802 .ifnum = QUIRK_ANY_INTERFACE, 2803 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2804 } 2805 }, 2806 { 2807 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217), 2808 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2809 USB_DEVICE_ID_MATCH_INT_CLASS | 2810 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2811 .bInterfaceClass = USB_CLASS_AUDIO, 2812 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2813 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2814 .vendor_name = "Hauppauge", 2815 .product_name = "HVR-950Q", 2816 .ifnum = QUIRK_ANY_INTERFACE, 2817 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2818 } 2819 }, 2820 { 2821 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b), 2822 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2823 USB_DEVICE_ID_MATCH_INT_CLASS | 2824 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2825 .bInterfaceClass = USB_CLASS_AUDIO, 2826 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2827 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2828 .vendor_name = "Hauppauge", 2829 .product_name = "HVR-950Q", 2830 .ifnum = QUIRK_ANY_INTERFACE, 2831 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2832 } 2833 }, 2834 { 2835 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e), 2836 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2837 USB_DEVICE_ID_MATCH_INT_CLASS | 2838 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2839 .bInterfaceClass = USB_CLASS_AUDIO, 2840 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2841 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2842 .vendor_name = "Hauppauge", 2843 .product_name = "HVR-950Q", 2844 .ifnum = QUIRK_ANY_INTERFACE, 2845 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2846 } 2847 }, 2848 { 2849 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f), 2850 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2851 USB_DEVICE_ID_MATCH_INT_CLASS | 2852 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2853 .bInterfaceClass = USB_CLASS_AUDIO, 2854 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2855 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2856 .vendor_name = "Hauppauge", 2857 .product_name = "HVR-950Q", 2858 .ifnum = QUIRK_ANY_INTERFACE, 2859 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2860 } 2861 }, 2862 { 2863 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240), 2864 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2865 USB_DEVICE_ID_MATCH_INT_CLASS | 2866 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2867 .bInterfaceClass = USB_CLASS_AUDIO, 2868 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2869 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2870 .vendor_name = "Hauppauge", 2871 .product_name = "HVR-850", 2872 .ifnum = QUIRK_ANY_INTERFACE, 2873 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2874 } 2875 }, 2876 { 2877 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280), 2878 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2879 USB_DEVICE_ID_MATCH_INT_CLASS | 2880 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2881 .bInterfaceClass = USB_CLASS_AUDIO, 2882 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2883 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2884 .vendor_name = "Hauppauge", 2885 .product_name = "HVR-950Q", 2886 .ifnum = QUIRK_ANY_INTERFACE, 2887 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2888 } 2889 }, 2890 { 2891 USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008), 2892 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2893 USB_DEVICE_ID_MATCH_INT_CLASS | 2894 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2895 .bInterfaceClass = USB_CLASS_AUDIO, 2896 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2897 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2898 .vendor_name = "Hauppauge", 2899 .product_name = "HVR-950Q", 2900 .ifnum = QUIRK_ANY_INTERFACE, 2901 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2902 } 2903 }, 2904 2905 /* Digidesign Mbox */ 2906 { 2907 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2908 USB_DEVICE(0x0dba, 0x1000), 2909 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2910 .vendor_name = "Digidesign", 2911 .product_name = "MBox", 2912 .ifnum = QUIRK_ANY_INTERFACE, 2913 .type = QUIRK_COMPOSITE, 2914 .data = (const struct snd_usb_audio_quirk[]){ 2915 { 2916 .ifnum = 0, 2917 .type = QUIRK_IGNORE_INTERFACE, 2918 }, 2919 { 2920 .ifnum = 1, 2921 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2922 .data = &(const struct audioformat) { 2923 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2924 .channels = 2, 2925 .iface = 1, 2926 .altsetting = 1, 2927 .altset_idx = 1, 2928 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2929 .endpoint = 0x02, 2930 .ep_attr = 0x01, 2931 .rates = SNDRV_PCM_RATE_44100 | 2932 SNDRV_PCM_RATE_48000, 2933 .rate_min = 44100, 2934 .rate_max = 48000, 2935 .nr_rates = 2, 2936 .rate_table = (unsigned int[]) { 2937 44100, 48000 2938 } 2939 } 2940 }, 2941 { 2942 .ifnum = -1 2943 } 2944 } 2945 2946 } 2947 }, 2948 2949 /* DIGIDESIGN MBOX 2 */ 2950 { 2951 USB_DEVICE(0x0dba, 0x3000), 2952 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2953 .vendor_name = "Digidesign", 2954 .product_name = "Mbox 2", 2955 .ifnum = QUIRK_ANY_INTERFACE, 2956 .type = QUIRK_COMPOSITE, 2957 .data = (const struct snd_usb_audio_quirk[]) { 2958 { 2959 .ifnum = 0, 2960 .type = QUIRK_IGNORE_INTERFACE 2961 }, 2962 { 2963 .ifnum = 1, 2964 .type = QUIRK_IGNORE_INTERFACE 2965 }, 2966 { 2967 .ifnum = 2, 2968 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2969 .data = &(const struct audioformat) { 2970 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2971 .channels = 2, 2972 .iface = 2, 2973 .altsetting = 2, 2974 .altset_idx = 1, 2975 .attributes = 0x00, 2976 .endpoint = 0x03, 2977 .ep_attr = USB_ENDPOINT_SYNC_ASYNC, 2978 .rates = SNDRV_PCM_RATE_48000, 2979 .rate_min = 48000, 2980 .rate_max = 48000, 2981 .nr_rates = 1, 2982 .rate_table = (unsigned int[]) { 2983 48000 2984 } 2985 } 2986 }, 2987 { 2988 .ifnum = 3, 2989 .type = QUIRK_IGNORE_INTERFACE 2990 }, 2991 { 2992 .ifnum = 4, 2993 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2994 .data = &(const struct audioformat) { 2995 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2996 .channels = 2, 2997 .iface = 4, 2998 .altsetting = 2, 2999 .altset_idx = 1, 3000 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 3001 .endpoint = 0x85, 3002 .ep_attr = USB_ENDPOINT_SYNC_SYNC, 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 * Some USB MIDI devices don't have an audio control interface, 3177 * so we have to grab MIDI streaming interfaces here. 3178 */ 3179 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 3180 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 3181 .bInterfaceClass = USB_CLASS_AUDIO, 3182 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 3183 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 3184 .ifnum = QUIRK_ANY_INTERFACE, 3185 .type = QUIRK_MIDI_STANDARD_INTERFACE 3186 } 3187 }, 3188 3189 { 3190 /* 3191 * The original product_name is "USB Sound Device", however this name 3192 * is also used by the CM106 based cards, so make it unique. 3193 */ 3194 USB_DEVICE(0x0d8c, 0x0103), 3195 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 3196 .product_name = "Audio Advantage MicroII", 3197 .ifnum = QUIRK_NO_INTERFACE 3198 } 3199 }, 3200 3201 #undef USB_DEVICE_VENDOR_SPEC 3202