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 USB_DEVICE(0x0582, 0x014d), 1836 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1837 /* .vendor_name = "BOSS", */ 1838 /* .product_name = "GT-100", */ 1839 .ifnum = QUIRK_ANY_INTERFACE, 1840 .type = QUIRK_COMPOSITE, 1841 .data = (const struct snd_usb_audio_quirk[]) { 1842 { 1843 .ifnum = 1, 1844 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1845 }, 1846 { 1847 .ifnum = 2, 1848 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1849 }, 1850 { 1851 .ifnum = 3, 1852 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1853 .data = & (const struct snd_usb_midi_endpoint_info) { 1854 .out_cables = 0x0001, 1855 .in_cables = 0x0001 1856 } 1857 }, 1858 { 1859 .ifnum = -1 1860 } 1861 } 1862 } 1863 }, 1864 1865 /* Guillemot devices */ 1866 { 1867 /* 1868 * This is for the "Windows Edition" where the external MIDI ports are 1869 * the only MIDI ports; the control data is reported through HID 1870 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1871 * compliant USB MIDI ports for external MIDI and controls. 1872 */ 1873 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1874 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1875 .vendor_name = "Hercules", 1876 .product_name = "DJ Console (WE)", 1877 .ifnum = 4, 1878 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1879 .data = & (const struct snd_usb_midi_endpoint_info) { 1880 .out_cables = 0x0001, 1881 .in_cables = 0x0001 1882 } 1883 } 1884 }, 1885 1886 /* Midiman/M-Audio devices */ 1887 { 1888 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1889 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1890 .vendor_name = "M-Audio", 1891 .product_name = "MidiSport 2x2", 1892 .ifnum = QUIRK_ANY_INTERFACE, 1893 .type = QUIRK_MIDI_MIDIMAN, 1894 .data = & (const struct snd_usb_midi_endpoint_info) { 1895 .out_cables = 0x0003, 1896 .in_cables = 0x0003 1897 } 1898 } 1899 }, 1900 { 1901 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1902 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1903 .vendor_name = "M-Audio", 1904 .product_name = "MidiSport 1x1", 1905 .ifnum = QUIRK_ANY_INTERFACE, 1906 .type = QUIRK_MIDI_MIDIMAN, 1907 .data = & (const struct snd_usb_midi_endpoint_info) { 1908 .out_cables = 0x0001, 1909 .in_cables = 0x0001 1910 } 1911 } 1912 }, 1913 { 1914 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1915 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1916 .vendor_name = "M-Audio", 1917 .product_name = "Keystation", 1918 .ifnum = QUIRK_ANY_INTERFACE, 1919 .type = QUIRK_MIDI_MIDIMAN, 1920 .data = & (const struct snd_usb_midi_endpoint_info) { 1921 .out_cables = 0x0001, 1922 .in_cables = 0x0001 1923 } 1924 } 1925 }, 1926 { 1927 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1928 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1929 .vendor_name = "M-Audio", 1930 .product_name = "MidiSport 4x4", 1931 .ifnum = QUIRK_ANY_INTERFACE, 1932 .type = QUIRK_MIDI_MIDIMAN, 1933 .data = & (const struct snd_usb_midi_endpoint_info) { 1934 .out_cables = 0x000f, 1935 .in_cables = 0x000f 1936 } 1937 } 1938 }, 1939 { 1940 /* 1941 * For hardware revision 1.05; in the later revisions (1.10 and 1942 * 1.21), 0x1031 is the ID for the device without firmware. 1943 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1944 */ 1945 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1946 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1947 .vendor_name = "M-Audio", 1948 .product_name = "MidiSport 8x8", 1949 .ifnum = QUIRK_ANY_INTERFACE, 1950 .type = QUIRK_MIDI_MIDIMAN, 1951 .data = & (const struct snd_usb_midi_endpoint_info) { 1952 .out_cables = 0x01ff, 1953 .in_cables = 0x01ff 1954 } 1955 } 1956 }, 1957 { 1958 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1959 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1960 .vendor_name = "M-Audio", 1961 .product_name = "MidiSport 8x8", 1962 .ifnum = QUIRK_ANY_INTERFACE, 1963 .type = QUIRK_MIDI_MIDIMAN, 1964 .data = & (const struct snd_usb_midi_endpoint_info) { 1965 .out_cables = 0x01ff, 1966 .in_cables = 0x01ff 1967 } 1968 } 1969 }, 1970 { 1971 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1972 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1973 .vendor_name = "M-Audio", 1974 .product_name = "MidiSport 2x4", 1975 .ifnum = QUIRK_ANY_INTERFACE, 1976 .type = QUIRK_MIDI_MIDIMAN, 1977 .data = & (const struct snd_usb_midi_endpoint_info) { 1978 .out_cables = 0x000f, 1979 .in_cables = 0x0003 1980 } 1981 } 1982 }, 1983 { 1984 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1985 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1986 .vendor_name = "M-Audio", 1987 .product_name = "Quattro", 1988 .ifnum = QUIRK_ANY_INTERFACE, 1989 .type = QUIRK_COMPOSITE, 1990 .data = & (const struct snd_usb_audio_quirk[]) { 1991 /* 1992 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1993 * and share endpoints with the other interfaces. 1994 * Ignore them. The other interfaces can do 24 bits, 1995 * but captured samples are big-endian (see usbaudio.c). 1996 */ 1997 { 1998 .ifnum = 0, 1999 .type = QUIRK_IGNORE_INTERFACE 2000 }, 2001 { 2002 .ifnum = 1, 2003 .type = QUIRK_IGNORE_INTERFACE 2004 }, 2005 { 2006 .ifnum = 2, 2007 .type = QUIRK_IGNORE_INTERFACE 2008 }, 2009 { 2010 .ifnum = 3, 2011 .type = QUIRK_IGNORE_INTERFACE 2012 }, 2013 { 2014 .ifnum = 4, 2015 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2016 }, 2017 { 2018 .ifnum = 5, 2019 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2020 }, 2021 { 2022 .ifnum = 6, 2023 .type = QUIRK_IGNORE_INTERFACE 2024 }, 2025 { 2026 .ifnum = 7, 2027 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2028 }, 2029 { 2030 .ifnum = 8, 2031 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2032 }, 2033 { 2034 .ifnum = 9, 2035 .type = QUIRK_MIDI_MIDIMAN, 2036 .data = & (const struct snd_usb_midi_endpoint_info) { 2037 .out_cables = 0x0001, 2038 .in_cables = 0x0001 2039 } 2040 }, 2041 { 2042 .ifnum = -1 2043 } 2044 } 2045 } 2046 }, 2047 { 2048 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 2049 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2050 .vendor_name = "M-Audio", 2051 .product_name = "AudioPhile", 2052 .ifnum = 6, 2053 .type = QUIRK_MIDI_MIDIMAN, 2054 .data = & (const struct snd_usb_midi_endpoint_info) { 2055 .out_cables = 0x0001, 2056 .in_cables = 0x0001 2057 } 2058 } 2059 }, 2060 { 2061 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 2062 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2063 .vendor_name = "M-Audio", 2064 .product_name = "Ozone", 2065 .ifnum = 3, 2066 .type = QUIRK_MIDI_MIDIMAN, 2067 .data = & (const struct snd_usb_midi_endpoint_info) { 2068 .out_cables = 0x0001, 2069 .in_cables = 0x0001 2070 } 2071 } 2072 }, 2073 { 2074 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 2075 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2076 .vendor_name = "M-Audio", 2077 .product_name = "OmniStudio", 2078 .ifnum = QUIRK_ANY_INTERFACE, 2079 .type = QUIRK_COMPOSITE, 2080 .data = & (const struct snd_usb_audio_quirk[]) { 2081 { 2082 .ifnum = 0, 2083 .type = QUIRK_IGNORE_INTERFACE 2084 }, 2085 { 2086 .ifnum = 1, 2087 .type = QUIRK_IGNORE_INTERFACE 2088 }, 2089 { 2090 .ifnum = 2, 2091 .type = QUIRK_IGNORE_INTERFACE 2092 }, 2093 { 2094 .ifnum = 3, 2095 .type = QUIRK_IGNORE_INTERFACE 2096 }, 2097 { 2098 .ifnum = 4, 2099 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2100 }, 2101 { 2102 .ifnum = 5, 2103 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2104 }, 2105 { 2106 .ifnum = 6, 2107 .type = QUIRK_IGNORE_INTERFACE 2108 }, 2109 { 2110 .ifnum = 7, 2111 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2112 }, 2113 { 2114 .ifnum = 8, 2115 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2116 }, 2117 { 2118 .ifnum = 9, 2119 .type = QUIRK_MIDI_MIDIMAN, 2120 .data = & (const struct snd_usb_midi_endpoint_info) { 2121 .out_cables = 0x0001, 2122 .in_cables = 0x0001 2123 } 2124 }, 2125 { 2126 .ifnum = -1 2127 } 2128 } 2129 } 2130 }, 2131 { 2132 USB_DEVICE(0x0763, 0x2019), 2133 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2134 /* .vendor_name = "M-Audio", */ 2135 /* .product_name = "Ozone Academic", */ 2136 .ifnum = QUIRK_ANY_INTERFACE, 2137 .type = QUIRK_COMPOSITE, 2138 .data = & (const struct snd_usb_audio_quirk[]) { 2139 { 2140 .ifnum = 0, 2141 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2142 }, 2143 { 2144 .ifnum = 1, 2145 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2146 }, 2147 { 2148 .ifnum = 2, 2149 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2150 }, 2151 { 2152 .ifnum = 3, 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_VENDOR_SPEC(0x0763, 0x2080), 2167 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2168 /* .vendor_name = "M-Audio", */ 2169 /* .product_name = "Fast Track Ultra", */ 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_MIXER, 2176 }, 2177 { 2178 .ifnum = 1, 2179 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2180 .data = & (const struct audioformat) { 2181 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2182 .channels = 8, 2183 .iface = 1, 2184 .altsetting = 1, 2185 .altset_idx = 1, 2186 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2187 .endpoint = 0x01, 2188 .ep_attr = 0x09, 2189 .rates = SNDRV_PCM_RATE_44100 | 2190 SNDRV_PCM_RATE_48000 | 2191 SNDRV_PCM_RATE_88200 | 2192 SNDRV_PCM_RATE_96000, 2193 .rate_min = 44100, 2194 .rate_max = 96000, 2195 .nr_rates = 4, 2196 .rate_table = (unsigned int[]) { 2197 44100, 48000, 88200, 96000 2198 } 2199 } 2200 }, 2201 { 2202 .ifnum = 2, 2203 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2204 .data = & (const struct audioformat) { 2205 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2206 .channels = 8, 2207 .iface = 2, 2208 .altsetting = 1, 2209 .altset_idx = 1, 2210 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2211 .endpoint = 0x81, 2212 .ep_attr = 0x05, 2213 .rates = SNDRV_PCM_RATE_44100 | 2214 SNDRV_PCM_RATE_48000 | 2215 SNDRV_PCM_RATE_88200 | 2216 SNDRV_PCM_RATE_96000, 2217 .rate_min = 44100, 2218 .rate_max = 96000, 2219 .nr_rates = 4, 2220 .rate_table = (unsigned int[]) { 2221 44100, 48000, 88200, 96000 2222 } 2223 } 2224 }, 2225 /* interface 3 (MIDI) is standard compliant */ 2226 { 2227 .ifnum = -1 2228 } 2229 } 2230 } 2231 }, 2232 { 2233 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2234 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2235 /* .vendor_name = "M-Audio", */ 2236 /* .product_name = "Fast Track Ultra 8R", */ 2237 .ifnum = QUIRK_ANY_INTERFACE, 2238 .type = QUIRK_COMPOSITE, 2239 .data = & (const struct snd_usb_audio_quirk[]) { 2240 { 2241 .ifnum = 0, 2242 .type = QUIRK_AUDIO_STANDARD_MIXER, 2243 }, 2244 { 2245 .ifnum = 1, 2246 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2247 .data = & (const struct audioformat) { 2248 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2249 .channels = 8, 2250 .iface = 1, 2251 .altsetting = 1, 2252 .altset_idx = 1, 2253 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2254 .endpoint = 0x01, 2255 .ep_attr = 0x09, 2256 .rates = SNDRV_PCM_RATE_44100 | 2257 SNDRV_PCM_RATE_48000 | 2258 SNDRV_PCM_RATE_88200 | 2259 SNDRV_PCM_RATE_96000, 2260 .rate_min = 44100, 2261 .rate_max = 96000, 2262 .nr_rates = 4, 2263 .rate_table = (unsigned int[]) { 2264 44100, 48000, 88200, 96000 2265 } 2266 } 2267 }, 2268 { 2269 .ifnum = 2, 2270 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2271 .data = & (const struct audioformat) { 2272 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2273 .channels = 8, 2274 .iface = 2, 2275 .altsetting = 1, 2276 .altset_idx = 1, 2277 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2278 .endpoint = 0x81, 2279 .ep_attr = 0x05, 2280 .rates = SNDRV_PCM_RATE_44100 | 2281 SNDRV_PCM_RATE_48000 | 2282 SNDRV_PCM_RATE_88200 | 2283 SNDRV_PCM_RATE_96000, 2284 .rate_min = 44100, 2285 .rate_max = 96000, 2286 .nr_rates = 4, 2287 .rate_table = (unsigned int[]) { 2288 44100, 48000, 88200, 96000 2289 } 2290 } 2291 }, 2292 /* interface 3 (MIDI) is standard compliant */ 2293 { 2294 .ifnum = -1 2295 } 2296 } 2297 } 2298 }, 2299 2300 /* Casio devices */ 2301 { 2302 USB_DEVICE(0x07cf, 0x6801), 2303 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2304 .vendor_name = "Casio", 2305 .product_name = "PL-40R", 2306 .ifnum = 0, 2307 .type = QUIRK_MIDI_YAMAHA 2308 } 2309 }, 2310 { 2311 /* this ID is used by several devices without a product ID */ 2312 USB_DEVICE(0x07cf, 0x6802), 2313 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2314 .vendor_name = "Casio", 2315 .product_name = "Keyboard", 2316 .ifnum = 0, 2317 .type = QUIRK_MIDI_YAMAHA 2318 } 2319 }, 2320 2321 /* Mark of the Unicorn devices */ 2322 { 2323 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2324 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2325 USB_DEVICE_ID_MATCH_PRODUCT | 2326 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2327 .idVendor = 0x07fd, 2328 .idProduct = 0x0001, 2329 .bDeviceSubClass = 2, 2330 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2331 .vendor_name = "MOTU", 2332 .product_name = "Fastlane", 2333 .ifnum = QUIRK_ANY_INTERFACE, 2334 .type = QUIRK_COMPOSITE, 2335 .data = & (const struct snd_usb_audio_quirk[]) { 2336 { 2337 .ifnum = 0, 2338 .type = QUIRK_MIDI_RAW_BYTES 2339 }, 2340 { 2341 .ifnum = 1, 2342 .type = QUIRK_IGNORE_INTERFACE 2343 }, 2344 { 2345 .ifnum = -1 2346 } 2347 } 2348 } 2349 }, 2350 2351 /* Emagic devices */ 2352 { 2353 USB_DEVICE(0x086a, 0x0001), 2354 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2355 .vendor_name = "Emagic", 2356 /* .product_name = "Unitor8", */ 2357 .ifnum = 2, 2358 .type = QUIRK_MIDI_EMAGIC, 2359 .data = & (const struct snd_usb_midi_endpoint_info) { 2360 .out_cables = 0x80ff, 2361 .in_cables = 0x80ff 2362 } 2363 } 2364 }, 2365 { 2366 USB_DEVICE(0x086a, 0x0002), 2367 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2368 .vendor_name = "Emagic", 2369 /* .product_name = "AMT8", */ 2370 .ifnum = 2, 2371 .type = QUIRK_MIDI_EMAGIC, 2372 .data = & (const struct snd_usb_midi_endpoint_info) { 2373 .out_cables = 0x80ff, 2374 .in_cables = 0x80ff 2375 } 2376 } 2377 }, 2378 { 2379 USB_DEVICE(0x086a, 0x0003), 2380 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2381 .vendor_name = "Emagic", 2382 /* .product_name = "MT4", */ 2383 .ifnum = 2, 2384 .type = QUIRK_MIDI_EMAGIC, 2385 .data = & (const struct snd_usb_midi_endpoint_info) { 2386 .out_cables = 0x800f, 2387 .in_cables = 0x8003 2388 } 2389 } 2390 }, 2391 2392 /* KORG devices */ 2393 { 2394 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2395 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2396 .vendor_name = "KORG, Inc.", 2397 /* .product_name = "PANDORA PX5D", */ 2398 .ifnum = 3, 2399 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2400 } 2401 }, 2402 2403 { 2404 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201), 2405 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2406 .vendor_name = "KORG, Inc.", 2407 /* .product_name = "ToneLab ST", */ 2408 .ifnum = 3, 2409 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2410 } 2411 }, 2412 2413 /* AKAI devices */ 2414 { 2415 USB_DEVICE(0x09e8, 0x0062), 2416 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2417 .vendor_name = "AKAI", 2418 .product_name = "MPD16", 2419 .ifnum = 0, 2420 .type = QUIRK_MIDI_AKAI, 2421 } 2422 }, 2423 2424 /* TerraTec devices */ 2425 { 2426 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2427 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2428 .vendor_name = "TerraTec", 2429 .product_name = "PHASE 26", 2430 .ifnum = 3, 2431 .type = QUIRK_MIDI_STANDARD_INTERFACE 2432 } 2433 }, 2434 { 2435 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2436 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2437 .vendor_name = "TerraTec", 2438 .product_name = "PHASE 26", 2439 .ifnum = 3, 2440 .type = QUIRK_MIDI_STANDARD_INTERFACE 2441 } 2442 }, 2443 { 2444 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2445 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2446 .vendor_name = "TerraTec", 2447 .product_name = "PHASE 26", 2448 .ifnum = 3, 2449 .type = QUIRK_MIDI_STANDARD_INTERFACE 2450 } 2451 }, 2452 { 2453 USB_DEVICE(0x0ccd, 0x0028), 2454 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2455 .vendor_name = "TerraTec", 2456 .product_name = "Aureon5.1MkII", 2457 .ifnum = QUIRK_NO_INTERFACE 2458 } 2459 }, 2460 { 2461 USB_DEVICE(0x0ccd, 0x0035), 2462 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2463 .vendor_name = "Miditech", 2464 .product_name = "Play'n Roll", 2465 .ifnum = 0, 2466 .type = QUIRK_MIDI_CME 2467 } 2468 }, 2469 2470 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ 2471 { 2472 USB_DEVICE(0x103d, 0x0100), 2473 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2474 .vendor_name = "Stanton", 2475 .product_name = "ScratchAmp", 2476 .ifnum = QUIRK_NO_INTERFACE 2477 } 2478 }, 2479 { 2480 USB_DEVICE(0x103d, 0x0101), 2481 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2482 .vendor_name = "Stanton", 2483 .product_name = "ScratchAmp", 2484 .ifnum = QUIRK_NO_INTERFACE 2485 } 2486 }, 2487 2488 /* Novation EMS devices */ 2489 { 2490 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2491 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2492 .vendor_name = "Novation", 2493 .product_name = "ReMOTE Audio/XStation", 2494 .ifnum = 4, 2495 .type = QUIRK_MIDI_NOVATION 2496 } 2497 }, 2498 { 2499 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2500 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2501 .vendor_name = "Novation", 2502 .product_name = "Speedio", 2503 .ifnum = 3, 2504 .type = QUIRK_MIDI_NOVATION 2505 } 2506 }, 2507 { 2508 USB_DEVICE(0x1235, 0x000e), 2509 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2510 /* .vendor_name = "Novation", */ 2511 /* .product_name = "Launchpad", */ 2512 .ifnum = 0, 2513 .type = QUIRK_MIDI_RAW_BYTES 2514 } 2515 }, 2516 { 2517 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2518 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2519 .vendor_name = "Novation", 2520 .product_name = "ReMOTE25", 2521 .ifnum = 0, 2522 .type = QUIRK_MIDI_NOVATION 2523 } 2524 }, 2525 2526 /* Access Music devices */ 2527 { 2528 /* VirusTI Desktop */ 2529 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2530 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2531 .ifnum = QUIRK_ANY_INTERFACE, 2532 .type = QUIRK_COMPOSITE, 2533 .data = &(const struct snd_usb_audio_quirk[]) { 2534 { 2535 .ifnum = 3, 2536 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2537 .data = &(const struct snd_usb_midi_endpoint_info) { 2538 .out_cables = 0x0003, 2539 .in_cables = 0x0003 2540 } 2541 }, 2542 { 2543 .ifnum = 4, 2544 .type = QUIRK_IGNORE_INTERFACE 2545 }, 2546 { 2547 .ifnum = -1 2548 } 2549 } 2550 } 2551 }, 2552 2553 /* */ 2554 { 2555 /* aka. Serato Scratch Live DJ Box */ 2556 USB_DEVICE(0x13e5, 0x0001), 2557 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2558 .vendor_name = "Rane", 2559 .product_name = "SL-1", 2560 .ifnum = QUIRK_NO_INTERFACE 2561 } 2562 }, 2563 2564 /* Native Instruments MK2 series */ 2565 { 2566 /* Komplete Audio 6 */ 2567 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2568 .idVendor = 0x17cc, 2569 .idProduct = 0x1000, 2570 }, 2571 { 2572 /* Traktor Audio 6 */ 2573 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2574 .idVendor = 0x17cc, 2575 .idProduct = 0x1010, 2576 }, 2577 { 2578 /* Traktor Audio 10 */ 2579 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2580 .idVendor = 0x17cc, 2581 .idProduct = 0x1020, 2582 }, 2583 2584 /* KeithMcMillen Stringport */ 2585 { 2586 USB_DEVICE(0x1f38, 0x0001), 2587 .bInterfaceClass = USB_CLASS_AUDIO, 2588 }, 2589 2590 /* Miditech devices */ 2591 { 2592 USB_DEVICE(0x4752, 0x0011), 2593 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2594 .vendor_name = "Miditech", 2595 .product_name = "Midistart-2", 2596 .ifnum = 0, 2597 .type = QUIRK_MIDI_CME 2598 } 2599 }, 2600 2601 /* Central Music devices */ 2602 { 2603 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2604 USB_DEVICE(0x7104, 0x2202), 2605 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2606 .ifnum = 0, 2607 .type = QUIRK_MIDI_CME 2608 } 2609 }, 2610 2611 /* Hauppauge HVR-950Q and HVR-850 */ 2612 { 2613 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200), 2614 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2615 USB_DEVICE_ID_MATCH_INT_CLASS | 2616 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2617 .bInterfaceClass = USB_CLASS_AUDIO, 2618 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2619 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2620 .vendor_name = "Hauppauge", 2621 .product_name = "HVR-950Q", 2622 .ifnum = QUIRK_ANY_INTERFACE, 2623 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2624 } 2625 }, 2626 { 2627 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240), 2628 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2629 USB_DEVICE_ID_MATCH_INT_CLASS | 2630 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2631 .bInterfaceClass = USB_CLASS_AUDIO, 2632 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2633 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2634 .vendor_name = "Hauppauge", 2635 .product_name = "HVR-850", 2636 .ifnum = QUIRK_ANY_INTERFACE, 2637 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2638 } 2639 }, 2640 { 2641 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210), 2642 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2643 USB_DEVICE_ID_MATCH_INT_CLASS | 2644 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2645 .bInterfaceClass = USB_CLASS_AUDIO, 2646 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2647 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2648 .vendor_name = "Hauppauge", 2649 .product_name = "HVR-950Q", 2650 .ifnum = QUIRK_ANY_INTERFACE, 2651 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2652 } 2653 }, 2654 { 2655 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217), 2656 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2657 USB_DEVICE_ID_MATCH_INT_CLASS | 2658 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2659 .bInterfaceClass = USB_CLASS_AUDIO, 2660 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2661 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2662 .vendor_name = "Hauppauge", 2663 .product_name = "HVR-950Q", 2664 .ifnum = QUIRK_ANY_INTERFACE, 2665 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2666 } 2667 }, 2668 { 2669 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b), 2670 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2671 USB_DEVICE_ID_MATCH_INT_CLASS | 2672 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2673 .bInterfaceClass = USB_CLASS_AUDIO, 2674 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2675 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2676 .vendor_name = "Hauppauge", 2677 .product_name = "HVR-950Q", 2678 .ifnum = QUIRK_ANY_INTERFACE, 2679 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2680 } 2681 }, 2682 { 2683 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e), 2684 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2685 USB_DEVICE_ID_MATCH_INT_CLASS | 2686 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2687 .bInterfaceClass = USB_CLASS_AUDIO, 2688 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2689 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2690 .vendor_name = "Hauppauge", 2691 .product_name = "HVR-950Q", 2692 .ifnum = QUIRK_ANY_INTERFACE, 2693 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2694 } 2695 }, 2696 { 2697 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f), 2698 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2699 USB_DEVICE_ID_MATCH_INT_CLASS | 2700 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2701 .bInterfaceClass = USB_CLASS_AUDIO, 2702 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2703 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2704 .vendor_name = "Hauppauge", 2705 .product_name = "HVR-950Q", 2706 .ifnum = QUIRK_ANY_INTERFACE, 2707 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2708 } 2709 }, 2710 { 2711 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280), 2712 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2713 USB_DEVICE_ID_MATCH_INT_CLASS | 2714 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2715 .bInterfaceClass = USB_CLASS_AUDIO, 2716 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2717 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2718 .vendor_name = "Hauppauge", 2719 .product_name = "HVR-950Q", 2720 .ifnum = QUIRK_ANY_INTERFACE, 2721 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2722 } 2723 }, 2724 { 2725 USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008), 2726 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2727 USB_DEVICE_ID_MATCH_INT_CLASS | 2728 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2729 .bInterfaceClass = USB_CLASS_AUDIO, 2730 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2731 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2732 .vendor_name = "Hauppauge", 2733 .product_name = "HVR-950Q", 2734 .ifnum = QUIRK_ANY_INTERFACE, 2735 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2736 } 2737 }, 2738 2739 /* Digidesign Mbox */ 2740 { 2741 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2742 USB_DEVICE(0x0dba, 0x1000), 2743 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2744 .vendor_name = "Digidesign", 2745 .product_name = "MBox", 2746 .ifnum = QUIRK_ANY_INTERFACE, 2747 .type = QUIRK_COMPOSITE, 2748 .data = (const struct snd_usb_audio_quirk[]){ 2749 { 2750 .ifnum = 0, 2751 .type = QUIRK_IGNORE_INTERFACE, 2752 }, 2753 { 2754 .ifnum = 1, 2755 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2756 .data = &(const struct audioformat) { 2757 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2758 .channels = 2, 2759 .iface = 1, 2760 .altsetting = 1, 2761 .altset_idx = 1, 2762 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2763 .endpoint = 0x02, 2764 .ep_attr = 0x01, 2765 .maxpacksize = 0x130, 2766 .rates = SNDRV_PCM_RATE_44100 | 2767 SNDRV_PCM_RATE_48000, 2768 .rate_min = 44100, 2769 .rate_max = 48000, 2770 .nr_rates = 2, 2771 .rate_table = (unsigned int[]) { 2772 44100, 48000 2773 } 2774 } 2775 }, 2776 { 2777 .ifnum = -1 2778 } 2779 } 2780 2781 } 2782 }, 2783 2784 { 2785 /* 2786 * Some USB MIDI devices don't have an audio control interface, 2787 * so we have to grab MIDI streaming interfaces here. 2788 */ 2789 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 2790 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2791 .bInterfaceClass = USB_CLASS_AUDIO, 2792 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 2793 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2794 .ifnum = QUIRK_ANY_INTERFACE, 2795 .type = QUIRK_MIDI_STANDARD_INTERFACE 2796 } 2797 }, 2798 2799 #undef USB_DEVICE_VENDOR_SPEC 2800