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