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