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