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 /* Roland SonicCell */ 1461 USB_DEVICE(0x0582, 0x00c2), 1462 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1463 .vendor_name = "Roland", 1464 .product_name = "SonicCell", 1465 .ifnum = QUIRK_ANY_INTERFACE, 1466 .type = QUIRK_COMPOSITE, 1467 .data = (const struct snd_usb_audio_quirk[]) { 1468 { 1469 .ifnum = 0, 1470 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1471 }, 1472 { 1473 .ifnum = 1, 1474 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1475 }, 1476 { 1477 .ifnum = 2, 1478 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1479 .data = & (const struct snd_usb_midi_endpoint_info) { 1480 .out_cables = 0x0001, 1481 .in_cables = 0x0001 1482 } 1483 }, 1484 { 1485 .ifnum = -1 1486 } 1487 } 1488 } 1489 }, 1490 { 1491 /* Edirol M-16DX */ 1492 /* FIXME: This quirk gives a good-working capture stream but the 1493 * playback seems problematic because of lacking of sync 1494 * with capture stream. It needs to sync with the capture 1495 * clock. As now, you'll get frequent sound distortions 1496 * via the playback. 1497 */ 1498 USB_DEVICE(0x0582, 0x00c4), 1499 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1500 .ifnum = QUIRK_ANY_INTERFACE, 1501 .type = QUIRK_COMPOSITE, 1502 .data = (const struct snd_usb_audio_quirk[]) { 1503 { 1504 .ifnum = 0, 1505 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1506 }, 1507 { 1508 .ifnum = 1, 1509 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1510 }, 1511 { 1512 .ifnum = 2, 1513 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1514 .data = & (const struct snd_usb_midi_endpoint_info) { 1515 .out_cables = 0x0001, 1516 .in_cables = 0x0001 1517 } 1518 }, 1519 { 1520 .ifnum = -1 1521 } 1522 } 1523 } 1524 }, 1525 { 1526 /* BOSS GT-10 */ 1527 USB_DEVICE(0x0582, 0x00da), 1528 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 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_STANDARD_INTERFACE 1535 }, 1536 { 1537 .ifnum = 1, 1538 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1539 }, 1540 { 1541 .ifnum = 2, 1542 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1543 .data = & (const struct snd_usb_midi_endpoint_info) { 1544 .out_cables = 0x0001, 1545 .in_cables = 0x0001 1546 } 1547 }, 1548 { 1549 .ifnum = -1 1550 } 1551 } 1552 } 1553 }, 1554 { 1555 /* Advanced modes of the Edirol UA-25EX. 1556 * For the standard mode, UA-25EX has ID 0582:00e7, which 1557 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1558 */ 1559 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6), 1560 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1561 .vendor_name = "EDIROL", 1562 .product_name = "UA-25EX", 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_EDIROL_UAXX 1569 }, 1570 { 1571 .ifnum = 1, 1572 .type = QUIRK_AUDIO_EDIROL_UAXX 1573 }, 1574 { 1575 .ifnum = 2, 1576 .type = QUIRK_AUDIO_EDIROL_UAXX 1577 }, 1578 { 1579 .ifnum = -1 1580 } 1581 } 1582 } 1583 }, 1584 { 1585 /* has ID 0x00ea when not in Advanced Driver mode */ 1586 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9), 1587 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1588 /* .vendor_name = "Roland", */ 1589 /* .product_name = "UA-1G", */ 1590 .ifnum = QUIRK_ANY_INTERFACE, 1591 .type = QUIRK_COMPOSITE, 1592 .data = (const struct snd_usb_audio_quirk[]) { 1593 { 1594 .ifnum = 0, 1595 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1596 }, 1597 { 1598 .ifnum = 1, 1599 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1600 }, 1601 { 1602 .ifnum = -1 1603 } 1604 } 1605 } 1606 }, 1607 { 1608 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104), 1609 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1610 /* .vendor_name = "Roland", */ 1611 /* .product_name = "UM-1G", */ 1612 .ifnum = 0, 1613 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1614 .data = & (const struct snd_usb_midi_endpoint_info) { 1615 .out_cables = 0x0001, 1616 .in_cables = 0x0001 1617 } 1618 } 1619 }, 1620 { 1621 /* Edirol UM-3G */ 1622 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108), 1623 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1624 .ifnum = 0, 1625 .type = QUIRK_MIDI_STANDARD_INTERFACE 1626 } 1627 }, 1628 { 1629 /* Boss JS-8 Jam Station */ 1630 USB_DEVICE(0x0582, 0x0109), 1631 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1632 /* .vendor_name = "BOSS", */ 1633 /* .product_name = "JS-8", */ 1634 .ifnum = QUIRK_ANY_INTERFACE, 1635 .type = QUIRK_COMPOSITE, 1636 .data = (const struct snd_usb_audio_quirk[]) { 1637 { 1638 .ifnum = 0, 1639 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1640 }, 1641 { 1642 .ifnum = 1, 1643 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1644 }, 1645 { 1646 .ifnum = 2, 1647 .type = QUIRK_MIDI_STANDARD_INTERFACE 1648 }, 1649 { 1650 .ifnum = -1 1651 } 1652 } 1653 } 1654 }, 1655 { 1656 /* has ID 0x0110 when not in Advanced Driver mode */ 1657 USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f), 1658 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1659 /* .vendor_name = "Roland", */ 1660 /* .product_name = "A-PRO", */ 1661 .ifnum = 1, 1662 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1663 .data = & (const struct snd_usb_midi_endpoint_info) { 1664 .out_cables = 0x0003, 1665 .in_cables = 0x0007 1666 } 1667 } 1668 }, 1669 { 1670 /* Roland GAIA SH-01 */ 1671 USB_DEVICE(0x0582, 0x0111), 1672 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 1673 .vendor_name = "Roland", 1674 .product_name = "GAIA", 1675 .ifnum = QUIRK_ANY_INTERFACE, 1676 .type = QUIRK_COMPOSITE, 1677 .data = (const struct snd_usb_audio_quirk[]) { 1678 { 1679 .ifnum = 0, 1680 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1681 }, 1682 { 1683 .ifnum = 1, 1684 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1685 }, 1686 { 1687 .ifnum = 2, 1688 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1689 .data = &(const struct snd_usb_midi_endpoint_info) { 1690 .out_cables = 0x0003, 1691 .in_cables = 0x0003 1692 } 1693 }, 1694 { 1695 .ifnum = -1 1696 } 1697 } 1698 } 1699 }, 1700 { 1701 USB_DEVICE(0x0582, 0x0113), 1702 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1703 /* .vendor_name = "BOSS", */ 1704 /* .product_name = "ME-25", */ 1705 .ifnum = QUIRK_ANY_INTERFACE, 1706 .type = QUIRK_COMPOSITE, 1707 .data = (const struct snd_usb_audio_quirk[]) { 1708 { 1709 .ifnum = 0, 1710 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1711 }, 1712 { 1713 .ifnum = 1, 1714 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1715 }, 1716 { 1717 .ifnum = 2, 1718 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1719 .data = & (const struct snd_usb_midi_endpoint_info) { 1720 .out_cables = 0x0001, 1721 .in_cables = 0x0001 1722 } 1723 }, 1724 { 1725 .ifnum = -1 1726 } 1727 } 1728 } 1729 }, 1730 { 1731 USB_DEVICE(0x0582, 0x0127), 1732 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1733 /* .vendor_name = "Roland", */ 1734 /* .product_name = "GR-55", */ 1735 .ifnum = QUIRK_ANY_INTERFACE, 1736 .type = QUIRK_COMPOSITE, 1737 .data = (const struct snd_usb_audio_quirk[]) { 1738 { 1739 .ifnum = 0, 1740 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1741 }, 1742 { 1743 .ifnum = 1, 1744 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1745 }, 1746 { 1747 .ifnum = 2, 1748 .type = QUIRK_MIDI_STANDARD_INTERFACE 1749 }, 1750 { 1751 .ifnum = -1 1752 } 1753 } 1754 } 1755 }, 1756 { 1757 /* Added support for Roland UM-ONE which differs from UM-1 */ 1758 USB_DEVICE(0x0582, 0x012a), 1759 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1760 /* .vendor_name = "ROLAND", */ 1761 /* .product_name = "UM-ONE", */ 1762 .ifnum = 0, 1763 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1764 .data = & (const struct snd_usb_midi_endpoint_info) { 1765 .out_cables = 0x0001, 1766 .in_cables = 0x0003 1767 } 1768 } 1769 }, 1770 { 1771 USB_DEVICE(0x0582, 0x011e), 1772 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1773 /* .vendor_name = "BOSS", */ 1774 /* .product_name = "BR-800", */ 1775 .ifnum = QUIRK_ANY_INTERFACE, 1776 .type = QUIRK_COMPOSITE, 1777 .data = (const struct snd_usb_audio_quirk[]) { 1778 { 1779 .ifnum = 0, 1780 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1781 }, 1782 { 1783 .ifnum = 1, 1784 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1785 }, 1786 { 1787 .ifnum = 2, 1788 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1789 .data = & (const struct snd_usb_midi_endpoint_info) { 1790 .out_cables = 0x0001, 1791 .in_cables = 0x0001 1792 } 1793 }, 1794 { 1795 .ifnum = -1 1796 } 1797 } 1798 } 1799 }, 1800 { 1801 USB_DEVICE(0x0582, 0x0130), 1802 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1803 /* .vendor_name = "BOSS", */ 1804 /* .product_name = "MICRO BR-80", */ 1805 .ifnum = QUIRK_ANY_INTERFACE, 1806 .type = QUIRK_COMPOSITE, 1807 .data = (const struct snd_usb_audio_quirk[]) { 1808 { 1809 .ifnum = 0, 1810 .type = QUIRK_IGNORE_INTERFACE 1811 }, 1812 { 1813 .ifnum = 1, 1814 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1815 }, 1816 { 1817 .ifnum = 2, 1818 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1819 }, 1820 { 1821 .ifnum = 3, 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 /* Guillemot devices */ 1836 { 1837 /* 1838 * This is for the "Windows Edition" where the external MIDI ports are 1839 * the only MIDI ports; the control data is reported through HID 1840 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1841 * compliant USB MIDI ports for external MIDI and controls. 1842 */ 1843 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1844 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1845 .vendor_name = "Hercules", 1846 .product_name = "DJ Console (WE)", 1847 .ifnum = 4, 1848 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1849 .data = & (const struct snd_usb_midi_endpoint_info) { 1850 .out_cables = 0x0001, 1851 .in_cables = 0x0001 1852 } 1853 } 1854 }, 1855 1856 /* Midiman/M-Audio devices */ 1857 { 1858 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1859 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1860 .vendor_name = "M-Audio", 1861 .product_name = "MidiSport 2x2", 1862 .ifnum = QUIRK_ANY_INTERFACE, 1863 .type = QUIRK_MIDI_MIDIMAN, 1864 .data = & (const struct snd_usb_midi_endpoint_info) { 1865 .out_cables = 0x0003, 1866 .in_cables = 0x0003 1867 } 1868 } 1869 }, 1870 { 1871 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1872 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1873 .vendor_name = "M-Audio", 1874 .product_name = "MidiSport 1x1", 1875 .ifnum = QUIRK_ANY_INTERFACE, 1876 .type = QUIRK_MIDI_MIDIMAN, 1877 .data = & (const struct snd_usb_midi_endpoint_info) { 1878 .out_cables = 0x0001, 1879 .in_cables = 0x0001 1880 } 1881 } 1882 }, 1883 { 1884 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1885 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1886 .vendor_name = "M-Audio", 1887 .product_name = "Keystation", 1888 .ifnum = QUIRK_ANY_INTERFACE, 1889 .type = QUIRK_MIDI_MIDIMAN, 1890 .data = & (const struct snd_usb_midi_endpoint_info) { 1891 .out_cables = 0x0001, 1892 .in_cables = 0x0001 1893 } 1894 } 1895 }, 1896 { 1897 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1898 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1899 .vendor_name = "M-Audio", 1900 .product_name = "MidiSport 4x4", 1901 .ifnum = QUIRK_ANY_INTERFACE, 1902 .type = QUIRK_MIDI_MIDIMAN, 1903 .data = & (const struct snd_usb_midi_endpoint_info) { 1904 .out_cables = 0x000f, 1905 .in_cables = 0x000f 1906 } 1907 } 1908 }, 1909 { 1910 /* 1911 * For hardware revision 1.05; in the later revisions (1.10 and 1912 * 1.21), 0x1031 is the ID for the device without firmware. 1913 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1914 */ 1915 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1916 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1917 .vendor_name = "M-Audio", 1918 .product_name = "MidiSport 8x8", 1919 .ifnum = QUIRK_ANY_INTERFACE, 1920 .type = QUIRK_MIDI_MIDIMAN, 1921 .data = & (const struct snd_usb_midi_endpoint_info) { 1922 .out_cables = 0x01ff, 1923 .in_cables = 0x01ff 1924 } 1925 } 1926 }, 1927 { 1928 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1929 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1930 .vendor_name = "M-Audio", 1931 .product_name = "MidiSport 8x8", 1932 .ifnum = QUIRK_ANY_INTERFACE, 1933 .type = QUIRK_MIDI_MIDIMAN, 1934 .data = & (const struct snd_usb_midi_endpoint_info) { 1935 .out_cables = 0x01ff, 1936 .in_cables = 0x01ff 1937 } 1938 } 1939 }, 1940 { 1941 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1942 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1943 .vendor_name = "M-Audio", 1944 .product_name = "MidiSport 2x4", 1945 .ifnum = QUIRK_ANY_INTERFACE, 1946 .type = QUIRK_MIDI_MIDIMAN, 1947 .data = & (const struct snd_usb_midi_endpoint_info) { 1948 .out_cables = 0x000f, 1949 .in_cables = 0x0003 1950 } 1951 } 1952 }, 1953 { 1954 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1955 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1956 .vendor_name = "M-Audio", 1957 .product_name = "Quattro", 1958 .ifnum = QUIRK_ANY_INTERFACE, 1959 .type = QUIRK_COMPOSITE, 1960 .data = & (const struct snd_usb_audio_quirk[]) { 1961 /* 1962 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1963 * and share endpoints with the other interfaces. 1964 * Ignore them. The other interfaces can do 24 bits, 1965 * but captured samples are big-endian (see usbaudio.c). 1966 */ 1967 { 1968 .ifnum = 0, 1969 .type = QUIRK_IGNORE_INTERFACE 1970 }, 1971 { 1972 .ifnum = 1, 1973 .type = QUIRK_IGNORE_INTERFACE 1974 }, 1975 { 1976 .ifnum = 2, 1977 .type = QUIRK_IGNORE_INTERFACE 1978 }, 1979 { 1980 .ifnum = 3, 1981 .type = QUIRK_IGNORE_INTERFACE 1982 }, 1983 { 1984 .ifnum = 4, 1985 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1986 }, 1987 { 1988 .ifnum = 5, 1989 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1990 }, 1991 { 1992 .ifnum = 6, 1993 .type = QUIRK_IGNORE_INTERFACE 1994 }, 1995 { 1996 .ifnum = 7, 1997 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1998 }, 1999 { 2000 .ifnum = 8, 2001 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2002 }, 2003 { 2004 .ifnum = 9, 2005 .type = QUIRK_MIDI_MIDIMAN, 2006 .data = & (const struct snd_usb_midi_endpoint_info) { 2007 .out_cables = 0x0001, 2008 .in_cables = 0x0001 2009 } 2010 }, 2011 { 2012 .ifnum = -1 2013 } 2014 } 2015 } 2016 }, 2017 { 2018 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 2019 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2020 .vendor_name = "M-Audio", 2021 .product_name = "AudioPhile", 2022 .ifnum = 6, 2023 .type = QUIRK_MIDI_MIDIMAN, 2024 .data = & (const struct snd_usb_midi_endpoint_info) { 2025 .out_cables = 0x0001, 2026 .in_cables = 0x0001 2027 } 2028 } 2029 }, 2030 { 2031 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 2032 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2033 .vendor_name = "M-Audio", 2034 .product_name = "Ozone", 2035 .ifnum = 3, 2036 .type = QUIRK_MIDI_MIDIMAN, 2037 .data = & (const struct snd_usb_midi_endpoint_info) { 2038 .out_cables = 0x0001, 2039 .in_cables = 0x0001 2040 } 2041 } 2042 }, 2043 { 2044 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 2045 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2046 .vendor_name = "M-Audio", 2047 .product_name = "OmniStudio", 2048 .ifnum = QUIRK_ANY_INTERFACE, 2049 .type = QUIRK_COMPOSITE, 2050 .data = & (const struct snd_usb_audio_quirk[]) { 2051 { 2052 .ifnum = 0, 2053 .type = QUIRK_IGNORE_INTERFACE 2054 }, 2055 { 2056 .ifnum = 1, 2057 .type = QUIRK_IGNORE_INTERFACE 2058 }, 2059 { 2060 .ifnum = 2, 2061 .type = QUIRK_IGNORE_INTERFACE 2062 }, 2063 { 2064 .ifnum = 3, 2065 .type = QUIRK_IGNORE_INTERFACE 2066 }, 2067 { 2068 .ifnum = 4, 2069 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2070 }, 2071 { 2072 .ifnum = 5, 2073 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2074 }, 2075 { 2076 .ifnum = 6, 2077 .type = QUIRK_IGNORE_INTERFACE 2078 }, 2079 { 2080 .ifnum = 7, 2081 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2082 }, 2083 { 2084 .ifnum = 8, 2085 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2086 }, 2087 { 2088 .ifnum = 9, 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 .ifnum = -1 2097 } 2098 } 2099 } 2100 }, 2101 { 2102 USB_DEVICE(0x0763, 0x2019), 2103 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2104 /* .vendor_name = "M-Audio", */ 2105 /* .product_name = "Ozone Academic", */ 2106 .ifnum = QUIRK_ANY_INTERFACE, 2107 .type = QUIRK_COMPOSITE, 2108 .data = & (const struct snd_usb_audio_quirk[]) { 2109 { 2110 .ifnum = 0, 2111 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2112 }, 2113 { 2114 .ifnum = 1, 2115 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2116 }, 2117 { 2118 .ifnum = 2, 2119 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2120 }, 2121 { 2122 .ifnum = 3, 2123 .type = QUIRK_MIDI_MIDIMAN, 2124 .data = & (const struct snd_usb_midi_endpoint_info) { 2125 .out_cables = 0x0001, 2126 .in_cables = 0x0001 2127 } 2128 }, 2129 { 2130 .ifnum = -1 2131 } 2132 } 2133 } 2134 }, 2135 { 2136 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080), 2137 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2138 /* .vendor_name = "M-Audio", */ 2139 /* .product_name = "Fast Track Ultra", */ 2140 .ifnum = QUIRK_ANY_INTERFACE, 2141 .type = QUIRK_COMPOSITE, 2142 .data = & (const struct snd_usb_audio_quirk[]) { 2143 { 2144 .ifnum = 0, 2145 .type = QUIRK_AUDIO_STANDARD_MIXER, 2146 }, 2147 { 2148 .ifnum = 1, 2149 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2150 .data = & (const struct audioformat) { 2151 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2152 .channels = 8, 2153 .iface = 1, 2154 .altsetting = 1, 2155 .altset_idx = 1, 2156 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2157 .endpoint = 0x01, 2158 .ep_attr = 0x09, 2159 .rates = SNDRV_PCM_RATE_44100 | 2160 SNDRV_PCM_RATE_48000 | 2161 SNDRV_PCM_RATE_88200 | 2162 SNDRV_PCM_RATE_96000, 2163 .rate_min = 44100, 2164 .rate_max = 96000, 2165 .nr_rates = 4, 2166 .rate_table = (unsigned int[]) { 2167 44100, 48000, 88200, 96000 2168 } 2169 } 2170 }, 2171 { 2172 .ifnum = 2, 2173 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2174 .data = & (const struct audioformat) { 2175 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2176 .channels = 8, 2177 .iface = 2, 2178 .altsetting = 1, 2179 .altset_idx = 1, 2180 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2181 .endpoint = 0x81, 2182 .ep_attr = 0x05, 2183 .rates = SNDRV_PCM_RATE_44100 | 2184 SNDRV_PCM_RATE_48000 | 2185 SNDRV_PCM_RATE_88200 | 2186 SNDRV_PCM_RATE_96000, 2187 .rate_min = 44100, 2188 .rate_max = 96000, 2189 .nr_rates = 4, 2190 .rate_table = (unsigned int[]) { 2191 44100, 48000, 88200, 96000 2192 } 2193 } 2194 }, 2195 /* interface 3 (MIDI) is standard compliant */ 2196 { 2197 .ifnum = -1 2198 } 2199 } 2200 } 2201 }, 2202 { 2203 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2204 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2205 /* .vendor_name = "M-Audio", */ 2206 /* .product_name = "Fast Track Ultra 8R", */ 2207 .ifnum = QUIRK_ANY_INTERFACE, 2208 .type = QUIRK_COMPOSITE, 2209 .data = & (const struct snd_usb_audio_quirk[]) { 2210 { 2211 .ifnum = 0, 2212 .type = QUIRK_AUDIO_STANDARD_MIXER, 2213 }, 2214 { 2215 .ifnum = 1, 2216 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2217 .data = & (const struct audioformat) { 2218 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2219 .channels = 8, 2220 .iface = 1, 2221 .altsetting = 1, 2222 .altset_idx = 1, 2223 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2224 .endpoint = 0x01, 2225 .ep_attr = 0x09, 2226 .rates = SNDRV_PCM_RATE_44100 | 2227 SNDRV_PCM_RATE_48000 | 2228 SNDRV_PCM_RATE_88200 | 2229 SNDRV_PCM_RATE_96000, 2230 .rate_min = 44100, 2231 .rate_max = 96000, 2232 .nr_rates = 4, 2233 .rate_table = (unsigned int[]) { 2234 44100, 48000, 88200, 96000 2235 } 2236 } 2237 }, 2238 { 2239 .ifnum = 2, 2240 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2241 .data = & (const struct audioformat) { 2242 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2243 .channels = 8, 2244 .iface = 2, 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 } 2261 }, 2262 /* interface 3 (MIDI) is standard compliant */ 2263 { 2264 .ifnum = -1 2265 } 2266 } 2267 } 2268 }, 2269 2270 /* Casio devices */ 2271 { 2272 USB_DEVICE(0x07cf, 0x6801), 2273 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2274 .vendor_name = "Casio", 2275 .product_name = "PL-40R", 2276 .ifnum = 0, 2277 .type = QUIRK_MIDI_YAMAHA 2278 } 2279 }, 2280 { 2281 /* this ID is used by several devices without a product ID */ 2282 USB_DEVICE(0x07cf, 0x6802), 2283 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2284 .vendor_name = "Casio", 2285 .product_name = "Keyboard", 2286 .ifnum = 0, 2287 .type = QUIRK_MIDI_YAMAHA 2288 } 2289 }, 2290 2291 /* Mark of the Unicorn devices */ 2292 { 2293 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2294 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2295 USB_DEVICE_ID_MATCH_PRODUCT | 2296 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2297 .idVendor = 0x07fd, 2298 .idProduct = 0x0001, 2299 .bDeviceSubClass = 2, 2300 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2301 .vendor_name = "MOTU", 2302 .product_name = "Fastlane", 2303 .ifnum = QUIRK_ANY_INTERFACE, 2304 .type = QUIRK_COMPOSITE, 2305 .data = & (const struct snd_usb_audio_quirk[]) { 2306 { 2307 .ifnum = 0, 2308 .type = QUIRK_MIDI_RAW_BYTES 2309 }, 2310 { 2311 .ifnum = 1, 2312 .type = QUIRK_IGNORE_INTERFACE 2313 }, 2314 { 2315 .ifnum = -1 2316 } 2317 } 2318 } 2319 }, 2320 2321 /* Emagic devices */ 2322 { 2323 USB_DEVICE(0x086a, 0x0001), 2324 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2325 .vendor_name = "Emagic", 2326 /* .product_name = "Unitor8", */ 2327 .ifnum = 2, 2328 .type = QUIRK_MIDI_EMAGIC, 2329 .data = & (const struct snd_usb_midi_endpoint_info) { 2330 .out_cables = 0x80ff, 2331 .in_cables = 0x80ff 2332 } 2333 } 2334 }, 2335 { 2336 USB_DEVICE(0x086a, 0x0002), 2337 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2338 .vendor_name = "Emagic", 2339 /* .product_name = "AMT8", */ 2340 .ifnum = 2, 2341 .type = QUIRK_MIDI_EMAGIC, 2342 .data = & (const struct snd_usb_midi_endpoint_info) { 2343 .out_cables = 0x80ff, 2344 .in_cables = 0x80ff 2345 } 2346 } 2347 }, 2348 { 2349 USB_DEVICE(0x086a, 0x0003), 2350 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2351 .vendor_name = "Emagic", 2352 /* .product_name = "MT4", */ 2353 .ifnum = 2, 2354 .type = QUIRK_MIDI_EMAGIC, 2355 .data = & (const struct snd_usb_midi_endpoint_info) { 2356 .out_cables = 0x800f, 2357 .in_cables = 0x8003 2358 } 2359 } 2360 }, 2361 2362 /* KORG devices */ 2363 { 2364 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2365 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2366 .vendor_name = "KORG, Inc.", 2367 /* .product_name = "PANDORA PX5D", */ 2368 .ifnum = 3, 2369 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2370 } 2371 }, 2372 2373 { 2374 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201), 2375 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2376 .vendor_name = "KORG, Inc.", 2377 /* .product_name = "ToneLab ST", */ 2378 .ifnum = 3, 2379 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2380 } 2381 }, 2382 2383 /* AKAI devices */ 2384 { 2385 USB_DEVICE(0x09e8, 0x0062), 2386 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2387 .vendor_name = "AKAI", 2388 .product_name = "MPD16", 2389 .ifnum = 0, 2390 .type = QUIRK_MIDI_AKAI, 2391 } 2392 }, 2393 2394 /* TerraTec devices */ 2395 { 2396 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2397 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2398 .vendor_name = "TerraTec", 2399 .product_name = "PHASE 26", 2400 .ifnum = 3, 2401 .type = QUIRK_MIDI_STANDARD_INTERFACE 2402 } 2403 }, 2404 { 2405 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2406 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2407 .vendor_name = "TerraTec", 2408 .product_name = "PHASE 26", 2409 .ifnum = 3, 2410 .type = QUIRK_MIDI_STANDARD_INTERFACE 2411 } 2412 }, 2413 { 2414 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2415 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2416 .vendor_name = "TerraTec", 2417 .product_name = "PHASE 26", 2418 .ifnum = 3, 2419 .type = QUIRK_MIDI_STANDARD_INTERFACE 2420 } 2421 }, 2422 { 2423 USB_DEVICE(0x0ccd, 0x0028), 2424 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2425 .vendor_name = "TerraTec", 2426 .product_name = "Aureon5.1MkII", 2427 .ifnum = QUIRK_NO_INTERFACE 2428 } 2429 }, 2430 { 2431 USB_DEVICE(0x0ccd, 0x0035), 2432 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2433 .vendor_name = "Miditech", 2434 .product_name = "Play'n Roll", 2435 .ifnum = 0, 2436 .type = QUIRK_MIDI_CME 2437 } 2438 }, 2439 2440 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ 2441 { 2442 USB_DEVICE(0x103d, 0x0100), 2443 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2444 .vendor_name = "Stanton", 2445 .product_name = "ScratchAmp", 2446 .ifnum = QUIRK_NO_INTERFACE 2447 } 2448 }, 2449 { 2450 USB_DEVICE(0x103d, 0x0101), 2451 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2452 .vendor_name = "Stanton", 2453 .product_name = "ScratchAmp", 2454 .ifnum = QUIRK_NO_INTERFACE 2455 } 2456 }, 2457 2458 /* Novation EMS devices */ 2459 { 2460 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2461 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2462 .vendor_name = "Novation", 2463 .product_name = "ReMOTE Audio/XStation", 2464 .ifnum = 4, 2465 .type = QUIRK_MIDI_NOVATION 2466 } 2467 }, 2468 { 2469 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2470 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2471 .vendor_name = "Novation", 2472 .product_name = "Speedio", 2473 .ifnum = 3, 2474 .type = QUIRK_MIDI_NOVATION 2475 } 2476 }, 2477 { 2478 USB_DEVICE(0x1235, 0x000e), 2479 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2480 /* .vendor_name = "Novation", */ 2481 /* .product_name = "Launchpad", */ 2482 .ifnum = 0, 2483 .type = QUIRK_MIDI_RAW_BYTES 2484 } 2485 }, 2486 { 2487 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2488 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2489 .vendor_name = "Novation", 2490 .product_name = "ReMOTE25", 2491 .ifnum = 0, 2492 .type = QUIRK_MIDI_NOVATION 2493 } 2494 }, 2495 2496 /* Access Music devices */ 2497 { 2498 /* VirusTI Desktop */ 2499 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2500 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2501 .ifnum = QUIRK_ANY_INTERFACE, 2502 .type = QUIRK_COMPOSITE, 2503 .data = &(const struct snd_usb_audio_quirk[]) { 2504 { 2505 .ifnum = 3, 2506 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2507 .data = &(const struct snd_usb_midi_endpoint_info) { 2508 .out_cables = 0x0003, 2509 .in_cables = 0x0003 2510 } 2511 }, 2512 { 2513 .ifnum = 4, 2514 .type = QUIRK_IGNORE_INTERFACE 2515 }, 2516 { 2517 .ifnum = -1 2518 } 2519 } 2520 } 2521 }, 2522 2523 /* */ 2524 { 2525 /* aka. Serato Scratch Live DJ Box */ 2526 USB_DEVICE(0x13e5, 0x0001), 2527 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2528 .vendor_name = "Rane", 2529 .product_name = "SL-1", 2530 .ifnum = QUIRK_NO_INTERFACE 2531 } 2532 }, 2533 2534 /* Native Instruments MK2 series */ 2535 { 2536 /* Komplete Audio 6 */ 2537 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2538 .idVendor = 0x17cc, 2539 .idProduct = 0x1000, 2540 }, 2541 { 2542 /* Traktor Audio 6 */ 2543 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2544 .idVendor = 0x17cc, 2545 .idProduct = 0x1010, 2546 }, 2547 { 2548 /* Traktor Audio 10 */ 2549 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2550 .idVendor = 0x17cc, 2551 .idProduct = 0x1020, 2552 }, 2553 2554 /* KeithMcMillen Stringport */ 2555 { 2556 USB_DEVICE(0x1f38, 0x0001), 2557 .bInterfaceClass = USB_CLASS_AUDIO, 2558 }, 2559 2560 /* Miditech devices */ 2561 { 2562 USB_DEVICE(0x4752, 0x0011), 2563 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2564 .vendor_name = "Miditech", 2565 .product_name = "Midistart-2", 2566 .ifnum = 0, 2567 .type = QUIRK_MIDI_CME 2568 } 2569 }, 2570 2571 /* Central Music devices */ 2572 { 2573 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2574 USB_DEVICE(0x7104, 0x2202), 2575 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2576 .ifnum = 0, 2577 .type = QUIRK_MIDI_CME 2578 } 2579 }, 2580 2581 /* Hauppauge HVR-950Q and HVR-850 */ 2582 { 2583 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200), 2584 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2585 USB_DEVICE_ID_MATCH_INT_CLASS | 2586 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2587 .bInterfaceClass = USB_CLASS_AUDIO, 2588 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2589 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2590 .vendor_name = "Hauppauge", 2591 .product_name = "HVR-950Q", 2592 .ifnum = QUIRK_ANY_INTERFACE, 2593 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2594 } 2595 }, 2596 { 2597 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240), 2598 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2599 USB_DEVICE_ID_MATCH_INT_CLASS | 2600 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2601 .bInterfaceClass = USB_CLASS_AUDIO, 2602 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2603 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2604 .vendor_name = "Hauppauge", 2605 .product_name = "HVR-850", 2606 .ifnum = QUIRK_ANY_INTERFACE, 2607 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2608 } 2609 }, 2610 { 2611 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210), 2612 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2613 USB_DEVICE_ID_MATCH_INT_CLASS | 2614 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2615 .bInterfaceClass = USB_CLASS_AUDIO, 2616 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2617 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2618 .vendor_name = "Hauppauge", 2619 .product_name = "HVR-950Q", 2620 .ifnum = QUIRK_ANY_INTERFACE, 2621 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2622 } 2623 }, 2624 { 2625 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217), 2626 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2627 USB_DEVICE_ID_MATCH_INT_CLASS | 2628 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2629 .bInterfaceClass = USB_CLASS_AUDIO, 2630 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2631 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2632 .vendor_name = "Hauppauge", 2633 .product_name = "HVR-950Q", 2634 .ifnum = QUIRK_ANY_INTERFACE, 2635 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2636 } 2637 }, 2638 { 2639 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b), 2640 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2641 USB_DEVICE_ID_MATCH_INT_CLASS | 2642 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2643 .bInterfaceClass = USB_CLASS_AUDIO, 2644 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2645 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2646 .vendor_name = "Hauppauge", 2647 .product_name = "HVR-950Q", 2648 .ifnum = QUIRK_ANY_INTERFACE, 2649 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2650 } 2651 }, 2652 { 2653 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e), 2654 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2655 USB_DEVICE_ID_MATCH_INT_CLASS | 2656 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2657 .bInterfaceClass = USB_CLASS_AUDIO, 2658 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2659 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2660 .vendor_name = "Hauppauge", 2661 .product_name = "HVR-950Q", 2662 .ifnum = QUIRK_ANY_INTERFACE, 2663 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2664 } 2665 }, 2666 { 2667 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f), 2668 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2669 USB_DEVICE_ID_MATCH_INT_CLASS | 2670 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2671 .bInterfaceClass = USB_CLASS_AUDIO, 2672 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2673 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2674 .vendor_name = "Hauppauge", 2675 .product_name = "HVR-950Q", 2676 .ifnum = QUIRK_ANY_INTERFACE, 2677 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2678 } 2679 }, 2680 { 2681 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280), 2682 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2683 USB_DEVICE_ID_MATCH_INT_CLASS | 2684 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2685 .bInterfaceClass = USB_CLASS_AUDIO, 2686 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2687 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2688 .vendor_name = "Hauppauge", 2689 .product_name = "HVR-950Q", 2690 .ifnum = QUIRK_ANY_INTERFACE, 2691 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2692 } 2693 }, 2694 { 2695 USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008), 2696 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2697 USB_DEVICE_ID_MATCH_INT_CLASS | 2698 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2699 .bInterfaceClass = USB_CLASS_AUDIO, 2700 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2701 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2702 .vendor_name = "Hauppauge", 2703 .product_name = "HVR-950Q", 2704 .ifnum = QUIRK_ANY_INTERFACE, 2705 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2706 } 2707 }, 2708 2709 /* Digidesign Mbox */ 2710 { 2711 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2712 USB_DEVICE(0x0dba, 0x1000), 2713 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2714 .vendor_name = "Digidesign", 2715 .product_name = "MBox", 2716 .ifnum = QUIRK_ANY_INTERFACE, 2717 .type = QUIRK_COMPOSITE, 2718 .data = (const struct snd_usb_audio_quirk[]){ 2719 { 2720 .ifnum = 0, 2721 .type = QUIRK_IGNORE_INTERFACE, 2722 }, 2723 { 2724 .ifnum = 1, 2725 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2726 .data = &(const struct audioformat) { 2727 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2728 .channels = 2, 2729 .iface = 1, 2730 .altsetting = 1, 2731 .altset_idx = 1, 2732 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2733 .endpoint = 0x02, 2734 .ep_attr = 0x01, 2735 .maxpacksize = 0x130, 2736 .rates = SNDRV_PCM_RATE_44100 | 2737 SNDRV_PCM_RATE_48000, 2738 .rate_min = 44100, 2739 .rate_max = 48000, 2740 .nr_rates = 2, 2741 .rate_table = (unsigned int[]) { 2742 44100, 48000 2743 } 2744 } 2745 }, 2746 { 2747 .ifnum = -1 2748 } 2749 } 2750 2751 } 2752 }, 2753 2754 { 2755 /* 2756 * Some USB MIDI devices don't have an audio control interface, 2757 * so we have to grab MIDI streaming interfaces here. 2758 */ 2759 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 2760 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2761 .bInterfaceClass = USB_CLASS_AUDIO, 2762 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 2763 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2764 .ifnum = QUIRK_ANY_INTERFACE, 2765 .type = QUIRK_MIDI_STANDARD_INTERFACE 2766 } 2767 }, 2768 2769 #undef USB_DEVICE_VENDOR_SPEC 2770