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 YAMAHA_DEVICE(0x2000, "DGP-7"), 273 YAMAHA_DEVICE(0x2001, "DGP-5"), 274 YAMAHA_DEVICE(0x2002, NULL), 275 YAMAHA_DEVICE(0x2003, NULL), 276 YAMAHA_DEVICE(0x5000, "CS1D"), 277 YAMAHA_DEVICE(0x5001, "DSP1D"), 278 YAMAHA_DEVICE(0x5002, "DME32"), 279 YAMAHA_DEVICE(0x5003, "DM2000"), 280 YAMAHA_DEVICE(0x5004, "02R96"), 281 YAMAHA_DEVICE(0x5005, "ACU16-C"), 282 YAMAHA_DEVICE(0x5006, "NHB32-C"), 283 YAMAHA_DEVICE(0x5007, "DM1000"), 284 YAMAHA_DEVICE(0x5008, "01V96"), 285 YAMAHA_DEVICE(0x5009, "SPX2000"), 286 YAMAHA_DEVICE(0x500a, "PM5D"), 287 YAMAHA_DEVICE(0x500b, "DME64N"), 288 YAMAHA_DEVICE(0x500c, "DME24N"), 289 YAMAHA_DEVICE(0x500d, NULL), 290 YAMAHA_DEVICE(0x500e, NULL), 291 YAMAHA_DEVICE(0x500f, NULL), 292 YAMAHA_DEVICE(0x7000, "DTX"), 293 YAMAHA_DEVICE(0x7010, "UB99"), 294 #undef YAMAHA_DEVICE 295 #undef YAMAHA_INTERFACE 296 297 /* 298 * Roland/RolandED/Edirol/BOSS devices 299 */ 300 { 301 USB_DEVICE(0x0582, 0x0000), 302 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 303 .vendor_name = "Roland", 304 .product_name = "UA-100", 305 .ifnum = QUIRK_ANY_INTERFACE, 306 .type = QUIRK_COMPOSITE, 307 .data = (const struct snd_usb_audio_quirk[]) { 308 { 309 .ifnum = 0, 310 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 311 .data = & (const struct audioformat) { 312 .formats = SNDRV_PCM_FMTBIT_S16_LE, 313 .channels = 4, 314 .iface = 0, 315 .altsetting = 1, 316 .altset_idx = 1, 317 .attributes = 0, 318 .endpoint = 0x01, 319 .ep_attr = 0x09, 320 .rates = SNDRV_PCM_RATE_CONTINUOUS, 321 .rate_min = 44100, 322 .rate_max = 44100, 323 } 324 }, 325 { 326 .ifnum = 1, 327 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 328 .data = & (const struct audioformat) { 329 .formats = SNDRV_PCM_FMTBIT_S16_LE, 330 .channels = 2, 331 .iface = 1, 332 .altsetting = 1, 333 .altset_idx = 1, 334 .attributes = UAC_EP_CS_ATTR_FILL_MAX, 335 .endpoint = 0x81, 336 .ep_attr = 0x05, 337 .rates = SNDRV_PCM_RATE_CONTINUOUS, 338 .rate_min = 44100, 339 .rate_max = 44100, 340 } 341 }, 342 { 343 .ifnum = 2, 344 .type = QUIRK_MIDI_FIXED_ENDPOINT, 345 .data = & (const struct snd_usb_midi_endpoint_info) { 346 .out_cables = 0x0007, 347 .in_cables = 0x0007 348 } 349 }, 350 { 351 .ifnum = -1 352 } 353 } 354 } 355 }, 356 { 357 USB_DEVICE(0x0582, 0x0002), 358 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 359 .vendor_name = "EDIROL", 360 .product_name = "UM-4", 361 .ifnum = QUIRK_ANY_INTERFACE, 362 .type = QUIRK_COMPOSITE, 363 .data = (const struct snd_usb_audio_quirk[]) { 364 { 365 .ifnum = 0, 366 .type = QUIRK_IGNORE_INTERFACE 367 }, 368 { 369 .ifnum = 1, 370 .type = QUIRK_IGNORE_INTERFACE 371 }, 372 { 373 .ifnum = 2, 374 .type = QUIRK_MIDI_FIXED_ENDPOINT, 375 .data = & (const struct snd_usb_midi_endpoint_info) { 376 .out_cables = 0x000f, 377 .in_cables = 0x000f 378 } 379 }, 380 { 381 .ifnum = -1 382 } 383 } 384 } 385 }, 386 { 387 USB_DEVICE(0x0582, 0x0003), 388 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 389 .vendor_name = "Roland", 390 .product_name = "SC-8850", 391 .ifnum = QUIRK_ANY_INTERFACE, 392 .type = QUIRK_COMPOSITE, 393 .data = (const struct snd_usb_audio_quirk[]) { 394 { 395 .ifnum = 0, 396 .type = QUIRK_IGNORE_INTERFACE 397 }, 398 { 399 .ifnum = 1, 400 .type = QUIRK_IGNORE_INTERFACE 401 }, 402 { 403 .ifnum = 2, 404 .type = QUIRK_MIDI_FIXED_ENDPOINT, 405 .data = & (const struct snd_usb_midi_endpoint_info) { 406 .out_cables = 0x003f, 407 .in_cables = 0x003f 408 } 409 }, 410 { 411 .ifnum = -1 412 } 413 } 414 } 415 }, 416 { 417 USB_DEVICE(0x0582, 0x0004), 418 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 419 .vendor_name = "Roland", 420 .product_name = "U-8", 421 .ifnum = QUIRK_ANY_INTERFACE, 422 .type = QUIRK_COMPOSITE, 423 .data = (const struct snd_usb_audio_quirk[]) { 424 { 425 .ifnum = 0, 426 .type = QUIRK_IGNORE_INTERFACE 427 }, 428 { 429 .ifnum = 1, 430 .type = QUIRK_IGNORE_INTERFACE 431 }, 432 { 433 .ifnum = 2, 434 .type = QUIRK_MIDI_FIXED_ENDPOINT, 435 .data = & (const struct snd_usb_midi_endpoint_info) { 436 .out_cables = 0x0005, 437 .in_cables = 0x0005 438 } 439 }, 440 { 441 .ifnum = -1 442 } 443 } 444 } 445 }, 446 { 447 /* Has ID 0x0099 when not in "Advanced Driver" mode. 448 * The UM-2EX has only one input, but we cannot detect this. */ 449 USB_DEVICE(0x0582, 0x0005), 450 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 451 .vendor_name = "EDIROL", 452 .product_name = "UM-2", 453 .ifnum = QUIRK_ANY_INTERFACE, 454 .type = QUIRK_COMPOSITE, 455 .data = (const struct snd_usb_audio_quirk[]) { 456 { 457 .ifnum = 0, 458 .type = QUIRK_IGNORE_INTERFACE 459 }, 460 { 461 .ifnum = 1, 462 .type = QUIRK_IGNORE_INTERFACE 463 }, 464 { 465 .ifnum = 2, 466 .type = QUIRK_MIDI_FIXED_ENDPOINT, 467 .data = & (const struct snd_usb_midi_endpoint_info) { 468 .out_cables = 0x0003, 469 .in_cables = 0x0003 470 } 471 }, 472 { 473 .ifnum = -1 474 } 475 } 476 } 477 }, 478 { 479 USB_DEVICE(0x0582, 0x0007), 480 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 481 .vendor_name = "Roland", 482 .product_name = "SC-8820", 483 .ifnum = QUIRK_ANY_INTERFACE, 484 .type = QUIRK_COMPOSITE, 485 .data = (const struct snd_usb_audio_quirk[]) { 486 { 487 .ifnum = 0, 488 .type = QUIRK_IGNORE_INTERFACE 489 }, 490 { 491 .ifnum = 1, 492 .type = QUIRK_IGNORE_INTERFACE 493 }, 494 { 495 .ifnum = 2, 496 .type = QUIRK_MIDI_FIXED_ENDPOINT, 497 .data = & (const struct snd_usb_midi_endpoint_info) { 498 .out_cables = 0x0013, 499 .in_cables = 0x0013 500 } 501 }, 502 { 503 .ifnum = -1 504 } 505 } 506 } 507 }, 508 { 509 USB_DEVICE(0x0582, 0x0008), 510 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 511 .vendor_name = "Roland", 512 .product_name = "PC-300", 513 .ifnum = QUIRK_ANY_INTERFACE, 514 .type = QUIRK_COMPOSITE, 515 .data = (const struct snd_usb_audio_quirk[]) { 516 { 517 .ifnum = 0, 518 .type = QUIRK_IGNORE_INTERFACE 519 }, 520 { 521 .ifnum = 1, 522 .type = QUIRK_IGNORE_INTERFACE 523 }, 524 { 525 .ifnum = 2, 526 .type = QUIRK_MIDI_FIXED_ENDPOINT, 527 .data = & (const struct snd_usb_midi_endpoint_info) { 528 .out_cables = 0x0001, 529 .in_cables = 0x0001 530 } 531 }, 532 { 533 .ifnum = -1 534 } 535 } 536 } 537 }, 538 { 539 /* has ID 0x009d when not in "Advanced Driver" mode */ 540 USB_DEVICE(0x0582, 0x0009), 541 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 542 .vendor_name = "EDIROL", 543 .product_name = "UM-1", 544 .ifnum = QUIRK_ANY_INTERFACE, 545 .type = QUIRK_COMPOSITE, 546 .data = (const struct snd_usb_audio_quirk[]) { 547 { 548 .ifnum = 0, 549 .type = QUIRK_IGNORE_INTERFACE 550 }, 551 { 552 .ifnum = 1, 553 .type = QUIRK_IGNORE_INTERFACE 554 }, 555 { 556 .ifnum = 2, 557 .type = QUIRK_MIDI_FIXED_ENDPOINT, 558 .data = & (const struct snd_usb_midi_endpoint_info) { 559 .out_cables = 0x0001, 560 .in_cables = 0x0001 561 } 562 }, 563 { 564 .ifnum = -1 565 } 566 } 567 } 568 }, 569 { 570 USB_DEVICE(0x0582, 0x000b), 571 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 572 .vendor_name = "Roland", 573 .product_name = "SK-500", 574 .ifnum = QUIRK_ANY_INTERFACE, 575 .type = QUIRK_COMPOSITE, 576 .data = (const struct snd_usb_audio_quirk[]) { 577 { 578 .ifnum = 0, 579 .type = QUIRK_IGNORE_INTERFACE 580 }, 581 { 582 .ifnum = 1, 583 .type = QUIRK_IGNORE_INTERFACE 584 }, 585 { 586 .ifnum = 2, 587 .type = QUIRK_MIDI_FIXED_ENDPOINT, 588 .data = & (const struct snd_usb_midi_endpoint_info) { 589 .out_cables = 0x0013, 590 .in_cables = 0x0013 591 } 592 }, 593 { 594 .ifnum = -1 595 } 596 } 597 } 598 }, 599 { 600 /* thanks to Emiliano Grilli <emillo@libero.it> 601 * for helping researching this data */ 602 USB_DEVICE(0x0582, 0x000c), 603 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 604 .vendor_name = "Roland", 605 .product_name = "SC-D70", 606 .ifnum = QUIRK_ANY_INTERFACE, 607 .type = QUIRK_COMPOSITE, 608 .data = (const struct snd_usb_audio_quirk[]) { 609 { 610 .ifnum = 0, 611 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 612 .data = & (const struct audioformat) { 613 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 614 .channels = 2, 615 .iface = 0, 616 .altsetting = 1, 617 .altset_idx = 1, 618 .attributes = 0, 619 .endpoint = 0x01, 620 .ep_attr = 0x01, 621 .rates = SNDRV_PCM_RATE_CONTINUOUS, 622 .rate_min = 44100, 623 .rate_max = 44100, 624 } 625 }, 626 { 627 .ifnum = 1, 628 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 629 .data = & (const struct audioformat) { 630 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 631 .channels = 2, 632 .iface = 1, 633 .altsetting = 1, 634 .altset_idx = 1, 635 .attributes = 0, 636 .endpoint = 0x81, 637 .ep_attr = 0x01, 638 .rates = SNDRV_PCM_RATE_CONTINUOUS, 639 .rate_min = 44100, 640 .rate_max = 44100, 641 } 642 }, 643 { 644 .ifnum = 2, 645 .type = QUIRK_MIDI_FIXED_ENDPOINT, 646 .data = & (const struct snd_usb_midi_endpoint_info) { 647 .out_cables = 0x0007, 648 .in_cables = 0x0007 649 } 650 }, 651 { 652 .ifnum = -1 653 } 654 } 655 } 656 }, 657 { /* 658 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5. 659 * If the advanced mode switch at the back of the unit is off, the 660 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks), 661 * but offers only 16-bit PCM. 662 * In advanced mode, the UA-5 will output S24_3LE samples (two 663 * channels) at the rate indicated on the front switch, including 664 * the 96kHz sample rate. 665 */ 666 USB_DEVICE(0x0582, 0x0010), 667 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 668 .vendor_name = "EDIROL", 669 .product_name = "UA-5", 670 .ifnum = QUIRK_ANY_INTERFACE, 671 .type = QUIRK_COMPOSITE, 672 .data = (const struct snd_usb_audio_quirk[]) { 673 { 674 .ifnum = 1, 675 .type = QUIRK_AUDIO_STANDARD_INTERFACE 676 }, 677 { 678 .ifnum = 2, 679 .type = QUIRK_AUDIO_STANDARD_INTERFACE 680 }, 681 { 682 .ifnum = -1 683 } 684 } 685 } 686 }, 687 { 688 /* has ID 0x0013 when not in "Advanced Driver" mode */ 689 USB_DEVICE(0x0582, 0x0012), 690 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 691 .vendor_name = "Roland", 692 .product_name = "XV-5050", 693 .ifnum = 0, 694 .type = QUIRK_MIDI_FIXED_ENDPOINT, 695 .data = & (const struct snd_usb_midi_endpoint_info) { 696 .out_cables = 0x0001, 697 .in_cables = 0x0001 698 } 699 } 700 }, 701 { 702 /* has ID 0x0015 when not in "Advanced Driver" mode */ 703 USB_DEVICE(0x0582, 0x0014), 704 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 705 .vendor_name = "EDIROL", 706 .product_name = "UM-880", 707 .ifnum = 0, 708 .type = QUIRK_MIDI_FIXED_ENDPOINT, 709 .data = & (const struct snd_usb_midi_endpoint_info) { 710 .out_cables = 0x01ff, 711 .in_cables = 0x01ff 712 } 713 } 714 }, 715 { 716 /* has ID 0x0017 when not in "Advanced Driver" mode */ 717 USB_DEVICE(0x0582, 0x0016), 718 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 719 .vendor_name = "EDIROL", 720 .product_name = "SD-90", 721 .ifnum = QUIRK_ANY_INTERFACE, 722 .type = QUIRK_COMPOSITE, 723 .data = (const struct snd_usb_audio_quirk[]) { 724 { 725 .ifnum = 0, 726 .type = QUIRK_AUDIO_STANDARD_INTERFACE 727 }, 728 { 729 .ifnum = 1, 730 .type = QUIRK_AUDIO_STANDARD_INTERFACE 731 }, 732 { 733 .ifnum = 2, 734 .type = QUIRK_MIDI_FIXED_ENDPOINT, 735 .data = & (const struct snd_usb_midi_endpoint_info) { 736 .out_cables = 0x000f, 737 .in_cables = 0x000f 738 } 739 }, 740 { 741 .ifnum = -1 742 } 743 } 744 } 745 }, 746 { 747 /* has ID 0x001c when not in "Advanced Driver" mode */ 748 USB_DEVICE(0x0582, 0x001b), 749 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 750 .vendor_name = "Roland", 751 .product_name = "MMP-2", 752 .ifnum = QUIRK_ANY_INTERFACE, 753 .type = QUIRK_COMPOSITE, 754 .data = (const struct snd_usb_audio_quirk[]) { 755 { 756 .ifnum = 0, 757 .type = QUIRK_IGNORE_INTERFACE 758 }, 759 { 760 .ifnum = 1, 761 .type = QUIRK_IGNORE_INTERFACE 762 }, 763 { 764 .ifnum = 2, 765 .type = QUIRK_MIDI_FIXED_ENDPOINT, 766 .data = & (const struct snd_usb_midi_endpoint_info) { 767 .out_cables = 0x0001, 768 .in_cables = 0x0001 769 } 770 }, 771 { 772 .ifnum = -1 773 } 774 } 775 } 776 }, 777 { 778 /* has ID 0x001e when not in "Advanced Driver" mode */ 779 USB_DEVICE(0x0582, 0x001d), 780 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 781 .vendor_name = "Roland", 782 .product_name = "V-SYNTH", 783 .ifnum = 0, 784 .type = QUIRK_MIDI_FIXED_ENDPOINT, 785 .data = & (const struct snd_usb_midi_endpoint_info) { 786 .out_cables = 0x0001, 787 .in_cables = 0x0001 788 } 789 } 790 }, 791 { 792 /* has ID 0x0024 when not in "Advanced Driver" mode */ 793 USB_DEVICE(0x0582, 0x0023), 794 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 795 .vendor_name = "EDIROL", 796 .product_name = "UM-550", 797 .ifnum = 0, 798 .type = QUIRK_MIDI_FIXED_ENDPOINT, 799 .data = & (const struct snd_usb_midi_endpoint_info) { 800 .out_cables = 0x003f, 801 .in_cables = 0x003f 802 } 803 } 804 }, 805 { 806 /* 807 * This quirk is for the "Advanced Driver" mode. If off, the UA-20 808 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM 809 * and no MIDI. 810 */ 811 USB_DEVICE(0x0582, 0x0025), 812 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 813 .vendor_name = "EDIROL", 814 .product_name = "UA-20", 815 .ifnum = QUIRK_ANY_INTERFACE, 816 .type = QUIRK_COMPOSITE, 817 .data = (const struct snd_usb_audio_quirk[]) { 818 { 819 .ifnum = 0, 820 .type = QUIRK_IGNORE_INTERFACE 821 }, 822 { 823 .ifnum = 1, 824 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 825 .data = & (const struct audioformat) { 826 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 827 .channels = 2, 828 .iface = 1, 829 .altsetting = 1, 830 .altset_idx = 1, 831 .attributes = 0, 832 .endpoint = 0x01, 833 .ep_attr = 0x01, 834 .rates = SNDRV_PCM_RATE_CONTINUOUS, 835 .rate_min = 44100, 836 .rate_max = 44100, 837 } 838 }, 839 { 840 .ifnum = 2, 841 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 842 .data = & (const struct audioformat) { 843 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 844 .channels = 2, 845 .iface = 2, 846 .altsetting = 1, 847 .altset_idx = 1, 848 .attributes = 0, 849 .endpoint = 0x82, 850 .ep_attr = 0x01, 851 .rates = SNDRV_PCM_RATE_CONTINUOUS, 852 .rate_min = 44100, 853 .rate_max = 44100, 854 } 855 }, 856 { 857 .ifnum = 3, 858 .type = QUIRK_MIDI_FIXED_ENDPOINT, 859 .data = & (const struct snd_usb_midi_endpoint_info) { 860 .out_cables = 0x0001, 861 .in_cables = 0x0001 862 } 863 }, 864 { 865 .ifnum = -1 866 } 867 } 868 } 869 }, 870 { 871 /* has ID 0x0028 when not in "Advanced Driver" mode */ 872 USB_DEVICE(0x0582, 0x0027), 873 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 874 .vendor_name = "EDIROL", 875 .product_name = "SD-20", 876 .ifnum = 0, 877 .type = QUIRK_MIDI_FIXED_ENDPOINT, 878 .data = & (const struct snd_usb_midi_endpoint_info) { 879 .out_cables = 0x0003, 880 .in_cables = 0x0007 881 } 882 } 883 }, 884 { 885 /* has ID 0x002a when not in "Advanced Driver" mode */ 886 USB_DEVICE(0x0582, 0x0029), 887 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 888 .vendor_name = "EDIROL", 889 .product_name = "SD-80", 890 .ifnum = 0, 891 .type = QUIRK_MIDI_FIXED_ENDPOINT, 892 .data = & (const struct snd_usb_midi_endpoint_info) { 893 .out_cables = 0x000f, 894 .in_cables = 0x000f 895 } 896 } 897 }, 898 { /* 899 * This quirk is for the "Advanced" modes of the Edirol UA-700. 900 * If the sample format switch is not in an advanced setting, the 901 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks), 902 * but offers only 16-bit PCM and no MIDI. 903 */ 904 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b), 905 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 906 .vendor_name = "EDIROL", 907 .product_name = "UA-700", 908 .ifnum = QUIRK_ANY_INTERFACE, 909 .type = QUIRK_COMPOSITE, 910 .data = (const struct snd_usb_audio_quirk[]) { 911 { 912 .ifnum = 1, 913 .type = QUIRK_AUDIO_EDIROL_UAXX 914 }, 915 { 916 .ifnum = 2, 917 .type = QUIRK_AUDIO_EDIROL_UAXX 918 }, 919 { 920 .ifnum = 3, 921 .type = QUIRK_AUDIO_EDIROL_UAXX 922 }, 923 { 924 .ifnum = -1 925 } 926 } 927 } 928 }, 929 { 930 /* has ID 0x002e when not in "Advanced Driver" mode */ 931 USB_DEVICE(0x0582, 0x002d), 932 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 933 .vendor_name = "Roland", 934 .product_name = "XV-2020", 935 .ifnum = 0, 936 .type = QUIRK_MIDI_FIXED_ENDPOINT, 937 .data = & (const struct snd_usb_midi_endpoint_info) { 938 .out_cables = 0x0001, 939 .in_cables = 0x0001 940 } 941 } 942 }, 943 { 944 /* has ID 0x0030 when not in "Advanced Driver" mode */ 945 USB_DEVICE(0x0582, 0x002f), 946 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 947 .vendor_name = "Roland", 948 .product_name = "VariOS", 949 .ifnum = 0, 950 .type = QUIRK_MIDI_FIXED_ENDPOINT, 951 .data = & (const struct snd_usb_midi_endpoint_info) { 952 .out_cables = 0x0007, 953 .in_cables = 0x0007 954 } 955 } 956 }, 957 { 958 /* has ID 0x0034 when not in "Advanced Driver" mode */ 959 USB_DEVICE(0x0582, 0x0033), 960 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 961 .vendor_name = "EDIROL", 962 .product_name = "PCR", 963 .ifnum = 0, 964 .type = QUIRK_MIDI_FIXED_ENDPOINT, 965 .data = & (const struct snd_usb_midi_endpoint_info) { 966 .out_cables = 0x0003, 967 .in_cables = 0x0007 968 } 969 } 970 }, 971 /* TODO: add Roland M-1000 support */ 972 { 973 /* 974 * Has ID 0x0038 when not in "Advanced Driver" mode; 975 * later revisions use IDs 0x0054 and 0x00a2. 976 */ 977 USB_DEVICE(0x0582, 0x0037), 978 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 979 .vendor_name = "Roland", 980 .product_name = "Digital Piano", 981 .ifnum = 0, 982 .type = QUIRK_MIDI_FIXED_ENDPOINT, 983 .data = & (const struct snd_usb_midi_endpoint_info) { 984 .out_cables = 0x0001, 985 .in_cables = 0x0001 986 } 987 } 988 }, 989 { 990 /* 991 * This quirk is for the "Advanced Driver" mode. If off, the GS-10 992 * has ID 0x003c and is standard compliant, but has only 16-bit PCM 993 * and no MIDI. 994 */ 995 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b), 996 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 997 .vendor_name = "BOSS", 998 .product_name = "GS-10", 999 .ifnum = QUIRK_ANY_INTERFACE, 1000 .type = QUIRK_COMPOSITE, 1001 .data = & (const struct snd_usb_audio_quirk[]) { 1002 { 1003 .ifnum = 1, 1004 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1005 }, 1006 { 1007 .ifnum = 2, 1008 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1009 }, 1010 { 1011 .ifnum = 3, 1012 .type = QUIRK_MIDI_STANDARD_INTERFACE 1013 }, 1014 { 1015 .ifnum = -1 1016 } 1017 } 1018 } 1019 }, 1020 { 1021 /* has ID 0x0041 when not in "Advanced Driver" mode */ 1022 USB_DEVICE(0x0582, 0x0040), 1023 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1024 .vendor_name = "Roland", 1025 .product_name = "GI-20", 1026 .ifnum = 0, 1027 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1028 .data = & (const struct snd_usb_midi_endpoint_info) { 1029 .out_cables = 0x0001, 1030 .in_cables = 0x0001 1031 } 1032 } 1033 }, 1034 { 1035 /* has ID 0x0043 when not in "Advanced Driver" mode */ 1036 USB_DEVICE(0x0582, 0x0042), 1037 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1038 .vendor_name = "Roland", 1039 .product_name = "RS-70", 1040 .ifnum = 0, 1041 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1042 .data = & (const struct snd_usb_midi_endpoint_info) { 1043 .out_cables = 0x0001, 1044 .in_cables = 0x0001 1045 } 1046 } 1047 }, 1048 { 1049 /* has ID 0x0049 when not in "Advanced Driver" mode */ 1050 USB_DEVICE(0x0582, 0x0047), 1051 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1052 /* .vendor_name = "EDIROL", */ 1053 /* .product_name = "UR-80", */ 1054 .ifnum = QUIRK_ANY_INTERFACE, 1055 .type = QUIRK_COMPOSITE, 1056 .data = (const struct snd_usb_audio_quirk[]) { 1057 /* in the 96 kHz modes, only interface 1 is there */ 1058 { 1059 .ifnum = 1, 1060 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1061 }, 1062 { 1063 .ifnum = 2, 1064 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1065 }, 1066 { 1067 .ifnum = -1 1068 } 1069 } 1070 } 1071 }, 1072 { 1073 /* has ID 0x004a when not in "Advanced Driver" mode */ 1074 USB_DEVICE(0x0582, 0x0048), 1075 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1076 /* .vendor_name = "EDIROL", */ 1077 /* .product_name = "UR-80", */ 1078 .ifnum = 0, 1079 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1080 .data = & (const struct snd_usb_midi_endpoint_info) { 1081 .out_cables = 0x0003, 1082 .in_cables = 0x0007 1083 } 1084 } 1085 }, 1086 /* TODO: add Edirol M-100FX support */ 1087 { 1088 /* has ID 0x004e when not in "Advanced Driver" mode */ 1089 USB_DEVICE(0x0582, 0x004c), 1090 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1091 .vendor_name = "EDIROL", 1092 .product_name = "PCR-A", 1093 .ifnum = QUIRK_ANY_INTERFACE, 1094 .type = QUIRK_COMPOSITE, 1095 .data = (const struct snd_usb_audio_quirk[]) { 1096 { 1097 .ifnum = 1, 1098 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1099 }, 1100 { 1101 .ifnum = 2, 1102 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1103 }, 1104 { 1105 .ifnum = -1 1106 } 1107 } 1108 } 1109 }, 1110 { 1111 /* has ID 0x004f when not in "Advanced Driver" mode */ 1112 USB_DEVICE(0x0582, 0x004d), 1113 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1114 .vendor_name = "EDIROL", 1115 .product_name = "PCR-A", 1116 .ifnum = 0, 1117 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1118 .data = & (const struct snd_usb_midi_endpoint_info) { 1119 .out_cables = 0x0003, 1120 .in_cables = 0x0007 1121 } 1122 } 1123 }, 1124 { 1125 /* 1126 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX 1127 * is standard compliant, but has only 16-bit PCM. 1128 */ 1129 USB_DEVICE(0x0582, 0x0050), 1130 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1131 .vendor_name = "EDIROL", 1132 .product_name = "UA-3FX", 1133 .ifnum = QUIRK_ANY_INTERFACE, 1134 .type = QUIRK_COMPOSITE, 1135 .data = (const struct snd_usb_audio_quirk[]) { 1136 { 1137 .ifnum = 1, 1138 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1139 }, 1140 { 1141 .ifnum = 2, 1142 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1143 }, 1144 { 1145 .ifnum = -1 1146 } 1147 } 1148 } 1149 }, 1150 { 1151 USB_DEVICE(0x0582, 0x0052), 1152 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1153 .vendor_name = "EDIROL", 1154 .product_name = "UM-1SX", 1155 .ifnum = 0, 1156 .type = QUIRK_MIDI_STANDARD_INTERFACE 1157 } 1158 }, 1159 { 1160 USB_DEVICE(0x0582, 0x0060), 1161 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1162 .vendor_name = "Roland", 1163 .product_name = "EXR Series", 1164 .ifnum = 0, 1165 .type = QUIRK_MIDI_STANDARD_INTERFACE 1166 } 1167 }, 1168 { 1169 /* has ID 0x0066 when not in "Advanced Driver" mode */ 1170 USB_DEVICE(0x0582, 0x0064), 1171 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1172 /* .vendor_name = "EDIROL", */ 1173 /* .product_name = "PCR-1", */ 1174 .ifnum = QUIRK_ANY_INTERFACE, 1175 .type = QUIRK_COMPOSITE, 1176 .data = (const struct snd_usb_audio_quirk[]) { 1177 { 1178 .ifnum = 1, 1179 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1180 }, 1181 { 1182 .ifnum = 2, 1183 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1184 }, 1185 { 1186 .ifnum = -1 1187 } 1188 } 1189 } 1190 }, 1191 { 1192 /* has ID 0x0067 when not in "Advanced Driver" mode */ 1193 USB_DEVICE(0x0582, 0x0065), 1194 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1195 /* .vendor_name = "EDIROL", */ 1196 /* .product_name = "PCR-1", */ 1197 .ifnum = 0, 1198 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1199 .data = & (const struct snd_usb_midi_endpoint_info) { 1200 .out_cables = 0x0001, 1201 .in_cables = 0x0003 1202 } 1203 } 1204 }, 1205 { 1206 /* has ID 0x006b when not in "Advanced Driver" mode */ 1207 USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a), 1208 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1209 .vendor_name = "Roland", 1210 .product_name = "SP-606", 1211 .ifnum = 3, 1212 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1213 .data = & (const struct snd_usb_midi_endpoint_info) { 1214 .out_cables = 0x0001, 1215 .in_cables = 0x0001 1216 } 1217 } 1218 }, 1219 { 1220 /* has ID 0x006e when not in "Advanced Driver" mode */ 1221 USB_DEVICE(0x0582, 0x006d), 1222 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1223 .vendor_name = "Roland", 1224 .product_name = "FANTOM-X", 1225 .ifnum = 0, 1226 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1227 .data = & (const struct snd_usb_midi_endpoint_info) { 1228 .out_cables = 0x0001, 1229 .in_cables = 0x0001 1230 } 1231 } 1232 }, 1233 { /* 1234 * This quirk is for the "Advanced" modes of the Edirol UA-25. 1235 * If the switch is not in an advanced setting, the UA-25 has 1236 * ID 0x0582/0x0073 and is standard compliant (no quirks), but 1237 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1238 */ 1239 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074), 1240 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1241 .vendor_name = "EDIROL", 1242 .product_name = "UA-25", 1243 .ifnum = QUIRK_ANY_INTERFACE, 1244 .type = QUIRK_COMPOSITE, 1245 .data = (const struct snd_usb_audio_quirk[]) { 1246 { 1247 .ifnum = 0, 1248 .type = QUIRK_AUDIO_EDIROL_UAXX 1249 }, 1250 { 1251 .ifnum = 1, 1252 .type = QUIRK_AUDIO_EDIROL_UAXX 1253 }, 1254 { 1255 .ifnum = 2, 1256 .type = QUIRK_AUDIO_EDIROL_UAXX 1257 }, 1258 { 1259 .ifnum = -1 1260 } 1261 } 1262 } 1263 }, 1264 { 1265 /* has ID 0x0076 when not in "Advanced Driver" mode */ 1266 USB_DEVICE(0x0582, 0x0075), 1267 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1268 .vendor_name = "BOSS", 1269 .product_name = "DR-880", 1270 .ifnum = 0, 1271 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1272 .data = & (const struct snd_usb_midi_endpoint_info) { 1273 .out_cables = 0x0001, 1274 .in_cables = 0x0001 1275 } 1276 } 1277 }, 1278 { 1279 /* has ID 0x007b when not in "Advanced Driver" mode */ 1280 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a), 1281 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1282 .vendor_name = "Roland", 1283 /* "RD" or "RD-700SX"? */ 1284 .ifnum = 0, 1285 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1286 .data = & (const struct snd_usb_midi_endpoint_info) { 1287 .out_cables = 0x0003, 1288 .in_cables = 0x0003 1289 } 1290 } 1291 }, 1292 { 1293 /* has ID 0x0081 when not in "Advanced Driver" mode */ 1294 USB_DEVICE(0x0582, 0x0080), 1295 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1296 .vendor_name = "Roland", 1297 .product_name = "G-70", 1298 .ifnum = 0, 1299 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1300 .data = & (const struct snd_usb_midi_endpoint_info) { 1301 .out_cables = 0x0001, 1302 .in_cables = 0x0001 1303 } 1304 } 1305 }, 1306 /* TODO: add Roland V-SYNTH XT support */ 1307 /* TODO: add BOSS GT-PRO support */ 1308 { 1309 /* has ID 0x008c when not in "Advanced Driver" mode */ 1310 USB_DEVICE(0x0582, 0x008b), 1311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1312 .vendor_name = "EDIROL", 1313 .product_name = "PC-50", 1314 .ifnum = 0, 1315 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1316 .data = & (const struct snd_usb_midi_endpoint_info) { 1317 .out_cables = 0x0001, 1318 .in_cables = 0x0001 1319 } 1320 } 1321 }, 1322 /* TODO: add Edirol PC-80 support */ 1323 { 1324 USB_DEVICE(0x0582, 0x0096), 1325 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1326 .vendor_name = "EDIROL", 1327 .product_name = "UA-1EX", 1328 .ifnum = QUIRK_ANY_INTERFACE, 1329 .type = QUIRK_COMPOSITE, 1330 .data = (const struct snd_usb_audio_quirk[]) { 1331 { 1332 .ifnum = 0, 1333 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1334 }, 1335 { 1336 .ifnum = 1, 1337 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1338 }, 1339 { 1340 .ifnum = -1 1341 } 1342 } 1343 } 1344 }, 1345 { 1346 USB_DEVICE(0x0582, 0x009a), 1347 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1348 .vendor_name = "EDIROL", 1349 .product_name = "UM-3EX", 1350 .ifnum = 0, 1351 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1352 .data = & (const struct snd_usb_midi_endpoint_info) { 1353 .out_cables = 0x000f, 1354 .in_cables = 0x000f 1355 } 1356 } 1357 }, 1358 { 1359 /* 1360 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX 1361 * is standard compliant, but has only 16-bit PCM and no MIDI. 1362 */ 1363 USB_DEVICE(0x0582, 0x00a3), 1364 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1365 .vendor_name = "EDIROL", 1366 .product_name = "UA-4FX", 1367 .ifnum = QUIRK_ANY_INTERFACE, 1368 .type = QUIRK_COMPOSITE, 1369 .data = (const struct snd_usb_audio_quirk[]) { 1370 { 1371 .ifnum = 0, 1372 .type = QUIRK_AUDIO_EDIROL_UAXX 1373 }, 1374 { 1375 .ifnum = 1, 1376 .type = QUIRK_AUDIO_EDIROL_UAXX 1377 }, 1378 { 1379 .ifnum = 2, 1380 .type = QUIRK_AUDIO_EDIROL_UAXX 1381 }, 1382 { 1383 .ifnum = -1 1384 } 1385 } 1386 } 1387 }, 1388 /* TODO: add Edirol MD-P1 support */ 1389 { 1390 USB_DEVICE(0x582, 0x00a6), 1391 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1392 .vendor_name = "Roland", 1393 .product_name = "Juno-G", 1394 .ifnum = 0, 1395 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1396 .data = & (const struct snd_usb_midi_endpoint_info) { 1397 .out_cables = 0x0001, 1398 .in_cables = 0x0001 1399 } 1400 } 1401 }, 1402 { 1403 /* Roland SH-201 */ 1404 USB_DEVICE(0x0582, 0x00ad), 1405 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1406 .vendor_name = "Roland", 1407 .product_name = "SH-201", 1408 .ifnum = QUIRK_ANY_INTERFACE, 1409 .type = QUIRK_COMPOSITE, 1410 .data = (const struct snd_usb_audio_quirk[]) { 1411 { 1412 .ifnum = 0, 1413 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1414 }, 1415 { 1416 .ifnum = 1, 1417 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1418 }, 1419 { 1420 .ifnum = 2, 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 .ifnum = -1 1429 } 1430 } 1431 } 1432 }, 1433 { 1434 /* Roland SonicCell */ 1435 USB_DEVICE(0x0582, 0x00c2), 1436 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1437 .vendor_name = "Roland", 1438 .product_name = "SonicCell", 1439 .ifnum = QUIRK_ANY_INTERFACE, 1440 .type = QUIRK_COMPOSITE, 1441 .data = (const struct snd_usb_audio_quirk[]) { 1442 { 1443 .ifnum = 0, 1444 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1445 }, 1446 { 1447 .ifnum = 1, 1448 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1449 }, 1450 { 1451 .ifnum = 2, 1452 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1453 .data = & (const struct snd_usb_midi_endpoint_info) { 1454 .out_cables = 0x0001, 1455 .in_cables = 0x0001 1456 } 1457 }, 1458 { 1459 .ifnum = -1 1460 } 1461 } 1462 } 1463 }, 1464 { 1465 /* Edirol M-16DX */ 1466 /* FIXME: This quirk gives a good-working capture stream but the 1467 * playback seems problematic because of lacking of sync 1468 * with capture stream. It needs to sync with the capture 1469 * clock. As now, you'll get frequent sound distortions 1470 * via the playback. 1471 */ 1472 USB_DEVICE(0x0582, 0x00c4), 1473 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1474 .ifnum = QUIRK_ANY_INTERFACE, 1475 .type = QUIRK_COMPOSITE, 1476 .data = (const struct snd_usb_audio_quirk[]) { 1477 { 1478 .ifnum = 0, 1479 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1480 }, 1481 { 1482 .ifnum = 1, 1483 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1484 }, 1485 { 1486 .ifnum = 2, 1487 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1488 .data = & (const struct snd_usb_midi_endpoint_info) { 1489 .out_cables = 0x0001, 1490 .in_cables = 0x0001 1491 } 1492 }, 1493 { 1494 .ifnum = -1 1495 } 1496 } 1497 } 1498 }, 1499 { 1500 /* BOSS GT-10 */ 1501 USB_DEVICE(0x0582, 0x00da), 1502 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1503 .ifnum = QUIRK_ANY_INTERFACE, 1504 .type = QUIRK_COMPOSITE, 1505 .data = (const struct snd_usb_audio_quirk[]) { 1506 { 1507 .ifnum = 0, 1508 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1509 }, 1510 { 1511 .ifnum = 1, 1512 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1513 }, 1514 { 1515 .ifnum = 2, 1516 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1517 .data = & (const struct snd_usb_midi_endpoint_info) { 1518 .out_cables = 0x0001, 1519 .in_cables = 0x0001 1520 } 1521 }, 1522 { 1523 .ifnum = -1 1524 } 1525 } 1526 } 1527 }, 1528 { 1529 /* Advanced modes of the Edirol UA-25EX. 1530 * For the standard mode, UA-25EX has ID 0582:00e7, which 1531 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1532 */ 1533 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6), 1534 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1535 .vendor_name = "EDIROL", 1536 .product_name = "UA-25EX", 1537 .ifnum = QUIRK_ANY_INTERFACE, 1538 .type = QUIRK_COMPOSITE, 1539 .data = (const struct snd_usb_audio_quirk[]) { 1540 { 1541 .ifnum = 0, 1542 .type = QUIRK_AUDIO_EDIROL_UAXX 1543 }, 1544 { 1545 .ifnum = 1, 1546 .type = QUIRK_AUDIO_EDIROL_UAXX 1547 }, 1548 { 1549 .ifnum = 2, 1550 .type = QUIRK_AUDIO_EDIROL_UAXX 1551 }, 1552 { 1553 .ifnum = -1 1554 } 1555 } 1556 } 1557 }, 1558 { 1559 /* has ID 0x00ea when not in Advanced Driver mode */ 1560 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e9), 1561 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1562 /* .vendor_name = "Roland", */ 1563 /* .product_name = "UA-1G", */ 1564 .ifnum = QUIRK_ANY_INTERFACE, 1565 .type = QUIRK_COMPOSITE, 1566 .data = (const struct snd_usb_audio_quirk[]) { 1567 { 1568 .ifnum = 0, 1569 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1570 }, 1571 { 1572 .ifnum = 1, 1573 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1574 }, 1575 { 1576 .ifnum = -1 1577 } 1578 } 1579 } 1580 }, 1581 { 1582 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0104), 1583 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1584 /* .vendor_name = "Roland", */ 1585 /* .product_name = "UM-1G", */ 1586 .ifnum = 0, 1587 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1588 .data = & (const struct snd_usb_midi_endpoint_info) { 1589 .out_cables = 0x0001, 1590 .in_cables = 0x0001 1591 } 1592 } 1593 }, 1594 { 1595 /* Boss JS-8 Jam Station */ 1596 USB_DEVICE(0x0582, 0x0109), 1597 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1598 /* .vendor_name = "BOSS", */ 1599 /* .product_name = "JS-8", */ 1600 .ifnum = QUIRK_ANY_INTERFACE, 1601 .type = QUIRK_COMPOSITE, 1602 .data = (const struct snd_usb_audio_quirk[]) { 1603 { 1604 .ifnum = 0, 1605 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1606 }, 1607 { 1608 .ifnum = 1, 1609 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1610 }, 1611 { 1612 .ifnum = 2, 1613 .type = QUIRK_MIDI_STANDARD_INTERFACE 1614 }, 1615 { 1616 .ifnum = -1 1617 } 1618 } 1619 } 1620 }, 1621 { 1622 /* has ID 0x0110 when not in Advanced Driver mode */ 1623 USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f), 1624 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1625 /* .vendor_name = "Roland", */ 1626 /* .product_name = "A-PRO", */ 1627 .ifnum = 1, 1628 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1629 .data = & (const struct snd_usb_midi_endpoint_info) { 1630 .out_cables = 0x0003, 1631 .in_cables = 0x0007 1632 } 1633 } 1634 }, 1635 { 1636 USB_DEVICE(0x0582, 0x0113), 1637 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1638 /* .vendor_name = "BOSS", */ 1639 /* .product_name = "ME-25", */ 1640 .ifnum = QUIRK_ANY_INTERFACE, 1641 .type = QUIRK_COMPOSITE, 1642 .data = (const struct snd_usb_audio_quirk[]) { 1643 { 1644 .ifnum = 0, 1645 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1646 }, 1647 { 1648 .ifnum = 1, 1649 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1650 }, 1651 { 1652 .ifnum = 2, 1653 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1654 .data = & (const struct snd_usb_midi_endpoint_info) { 1655 .out_cables = 0x0001, 1656 .in_cables = 0x0001 1657 } 1658 }, 1659 { 1660 .ifnum = -1 1661 } 1662 } 1663 } 1664 }, 1665 { 1666 USB_DEVICE(0x0582, 0x0127), 1667 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1668 /* .vendor_name = "Roland", */ 1669 /* .product_name = "GR-55", */ 1670 .ifnum = QUIRK_ANY_INTERFACE, 1671 .type = QUIRK_COMPOSITE, 1672 .data = (const struct snd_usb_audio_quirk[]) { 1673 { 1674 .ifnum = 0, 1675 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1676 }, 1677 { 1678 .ifnum = 1, 1679 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1680 }, 1681 { 1682 .ifnum = 2, 1683 .type = QUIRK_MIDI_STANDARD_INTERFACE 1684 }, 1685 { 1686 .ifnum = -1 1687 } 1688 } 1689 } 1690 }, 1691 { 1692 /* Added support for Roland UM-ONE which differs from UM-1 */ 1693 USB_DEVICE(0x0582, 0x012a), 1694 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1695 /* .vendor_name = "ROLAND", */ 1696 /* .product_name = "UM-ONE", */ 1697 .ifnum = 0, 1698 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1699 .data = & (const struct snd_usb_midi_endpoint_info) { 1700 .out_cables = 0x0001, 1701 .in_cables = 0x0003 1702 } 1703 } 1704 }, 1705 { 1706 USB_DEVICE(0x0582, 0x011e), 1707 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1708 /* .vendor_name = "BOSS", */ 1709 /* .product_name = "BR-800", */ 1710 .ifnum = QUIRK_ANY_INTERFACE, 1711 .type = QUIRK_COMPOSITE, 1712 .data = (const struct snd_usb_audio_quirk[]) { 1713 { 1714 .ifnum = 0, 1715 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1716 }, 1717 { 1718 .ifnum = 1, 1719 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1720 }, 1721 { 1722 .ifnum = 2, 1723 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1724 .data = & (const struct snd_usb_midi_endpoint_info) { 1725 .out_cables = 0x0001, 1726 .in_cables = 0x0001 1727 } 1728 }, 1729 { 1730 .ifnum = -1 1731 } 1732 } 1733 } 1734 }, 1735 { 1736 USB_DEVICE(0x0582, 0x0130), 1737 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1738 /* .vendor_name = "BOSS", */ 1739 /* .product_name = "MICRO BR-80", */ 1740 .ifnum = QUIRK_ANY_INTERFACE, 1741 .type = QUIRK_COMPOSITE, 1742 .data = (const struct snd_usb_audio_quirk[]) { 1743 { 1744 .ifnum = 0, 1745 .type = QUIRK_IGNORE_INTERFACE 1746 }, 1747 { 1748 .ifnum = 1, 1749 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1750 }, 1751 { 1752 .ifnum = 2, 1753 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1754 }, 1755 { 1756 .ifnum = 3, 1757 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1758 .data = & (const struct snd_usb_midi_endpoint_info) { 1759 .out_cables = 0x0001, 1760 .in_cables = 0x0001 1761 } 1762 }, 1763 { 1764 .ifnum = -1 1765 } 1766 } 1767 } 1768 }, 1769 1770 /* Guillemot devices */ 1771 { 1772 /* 1773 * This is for the "Windows Edition" where the external MIDI ports are 1774 * the only MIDI ports; the control data is reported through HID 1775 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1776 * compliant USB MIDI ports for external MIDI and controls. 1777 */ 1778 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1779 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1780 .vendor_name = "Hercules", 1781 .product_name = "DJ Console (WE)", 1782 .ifnum = 4, 1783 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1784 .data = & (const struct snd_usb_midi_endpoint_info) { 1785 .out_cables = 0x0001, 1786 .in_cables = 0x0001 1787 } 1788 } 1789 }, 1790 1791 /* Midiman/M-Audio devices */ 1792 { 1793 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1794 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1795 .vendor_name = "M-Audio", 1796 .product_name = "MidiSport 2x2", 1797 .ifnum = QUIRK_ANY_INTERFACE, 1798 .type = QUIRK_MIDI_MIDIMAN, 1799 .data = & (const struct snd_usb_midi_endpoint_info) { 1800 .out_cables = 0x0003, 1801 .in_cables = 0x0003 1802 } 1803 } 1804 }, 1805 { 1806 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1807 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1808 .vendor_name = "M-Audio", 1809 .product_name = "MidiSport 1x1", 1810 .ifnum = QUIRK_ANY_INTERFACE, 1811 .type = QUIRK_MIDI_MIDIMAN, 1812 .data = & (const struct snd_usb_midi_endpoint_info) { 1813 .out_cables = 0x0001, 1814 .in_cables = 0x0001 1815 } 1816 } 1817 }, 1818 { 1819 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1820 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1821 .vendor_name = "M-Audio", 1822 .product_name = "Keystation", 1823 .ifnum = QUIRK_ANY_INTERFACE, 1824 .type = QUIRK_MIDI_MIDIMAN, 1825 .data = & (const struct snd_usb_midi_endpoint_info) { 1826 .out_cables = 0x0001, 1827 .in_cables = 0x0001 1828 } 1829 } 1830 }, 1831 { 1832 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1833 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1834 .vendor_name = "M-Audio", 1835 .product_name = "MidiSport 4x4", 1836 .ifnum = QUIRK_ANY_INTERFACE, 1837 .type = QUIRK_MIDI_MIDIMAN, 1838 .data = & (const struct snd_usb_midi_endpoint_info) { 1839 .out_cables = 0x000f, 1840 .in_cables = 0x000f 1841 } 1842 } 1843 }, 1844 { 1845 /* 1846 * For hardware revision 1.05; in the later revisions (1.10 and 1847 * 1.21), 0x1031 is the ID for the device without firmware. 1848 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1849 */ 1850 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1851 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1852 .vendor_name = "M-Audio", 1853 .product_name = "MidiSport 8x8", 1854 .ifnum = QUIRK_ANY_INTERFACE, 1855 .type = QUIRK_MIDI_MIDIMAN, 1856 .data = & (const struct snd_usb_midi_endpoint_info) { 1857 .out_cables = 0x01ff, 1858 .in_cables = 0x01ff 1859 } 1860 } 1861 }, 1862 { 1863 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1864 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1865 .vendor_name = "M-Audio", 1866 .product_name = "MidiSport 8x8", 1867 .ifnum = QUIRK_ANY_INTERFACE, 1868 .type = QUIRK_MIDI_MIDIMAN, 1869 .data = & (const struct snd_usb_midi_endpoint_info) { 1870 .out_cables = 0x01ff, 1871 .in_cables = 0x01ff 1872 } 1873 } 1874 }, 1875 { 1876 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1877 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1878 .vendor_name = "M-Audio", 1879 .product_name = "MidiSport 2x4", 1880 .ifnum = QUIRK_ANY_INTERFACE, 1881 .type = QUIRK_MIDI_MIDIMAN, 1882 .data = & (const struct snd_usb_midi_endpoint_info) { 1883 .out_cables = 0x000f, 1884 .in_cables = 0x0003 1885 } 1886 } 1887 }, 1888 { 1889 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1890 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1891 .vendor_name = "M-Audio", 1892 .product_name = "Quattro", 1893 .ifnum = QUIRK_ANY_INTERFACE, 1894 .type = QUIRK_COMPOSITE, 1895 .data = & (const struct snd_usb_audio_quirk[]) { 1896 /* 1897 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1898 * and share endpoints with the other interfaces. 1899 * Ignore them. The other interfaces can do 24 bits, 1900 * but captured samples are big-endian (see usbaudio.c). 1901 */ 1902 { 1903 .ifnum = 0, 1904 .type = QUIRK_IGNORE_INTERFACE 1905 }, 1906 { 1907 .ifnum = 1, 1908 .type = QUIRK_IGNORE_INTERFACE 1909 }, 1910 { 1911 .ifnum = 2, 1912 .type = QUIRK_IGNORE_INTERFACE 1913 }, 1914 { 1915 .ifnum = 3, 1916 .type = QUIRK_IGNORE_INTERFACE 1917 }, 1918 { 1919 .ifnum = 4, 1920 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1921 }, 1922 { 1923 .ifnum = 5, 1924 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1925 }, 1926 { 1927 .ifnum = 6, 1928 .type = QUIRK_IGNORE_INTERFACE 1929 }, 1930 { 1931 .ifnum = 7, 1932 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1933 }, 1934 { 1935 .ifnum = 8, 1936 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1937 }, 1938 { 1939 .ifnum = 9, 1940 .type = QUIRK_MIDI_MIDIMAN, 1941 .data = & (const struct snd_usb_midi_endpoint_info) { 1942 .out_cables = 0x0001, 1943 .in_cables = 0x0001 1944 } 1945 }, 1946 { 1947 .ifnum = -1 1948 } 1949 } 1950 } 1951 }, 1952 { 1953 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 1954 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1955 .vendor_name = "M-Audio", 1956 .product_name = "AudioPhile", 1957 .ifnum = 6, 1958 .type = QUIRK_MIDI_MIDIMAN, 1959 .data = & (const struct snd_usb_midi_endpoint_info) { 1960 .out_cables = 0x0001, 1961 .in_cables = 0x0001 1962 } 1963 } 1964 }, 1965 { 1966 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 1967 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1968 .vendor_name = "M-Audio", 1969 .product_name = "Ozone", 1970 .ifnum = 3, 1971 .type = QUIRK_MIDI_MIDIMAN, 1972 .data = & (const struct snd_usb_midi_endpoint_info) { 1973 .out_cables = 0x0001, 1974 .in_cables = 0x0001 1975 } 1976 } 1977 }, 1978 { 1979 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 1980 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1981 .vendor_name = "M-Audio", 1982 .product_name = "OmniStudio", 1983 .ifnum = QUIRK_ANY_INTERFACE, 1984 .type = QUIRK_COMPOSITE, 1985 .data = & (const struct snd_usb_audio_quirk[]) { 1986 { 1987 .ifnum = 0, 1988 .type = QUIRK_IGNORE_INTERFACE 1989 }, 1990 { 1991 .ifnum = 1, 1992 .type = QUIRK_IGNORE_INTERFACE 1993 }, 1994 { 1995 .ifnum = 2, 1996 .type = QUIRK_IGNORE_INTERFACE 1997 }, 1998 { 1999 .ifnum = 3, 2000 .type = QUIRK_IGNORE_INTERFACE 2001 }, 2002 { 2003 .ifnum = 4, 2004 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2005 }, 2006 { 2007 .ifnum = 5, 2008 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2009 }, 2010 { 2011 .ifnum = 6, 2012 .type = QUIRK_IGNORE_INTERFACE 2013 }, 2014 { 2015 .ifnum = 7, 2016 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2017 }, 2018 { 2019 .ifnum = 8, 2020 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2021 }, 2022 { 2023 .ifnum = 9, 2024 .type = QUIRK_MIDI_MIDIMAN, 2025 .data = & (const struct snd_usb_midi_endpoint_info) { 2026 .out_cables = 0x0001, 2027 .in_cables = 0x0001 2028 } 2029 }, 2030 { 2031 .ifnum = -1 2032 } 2033 } 2034 } 2035 }, 2036 { 2037 USB_DEVICE(0x0763, 0x2019), 2038 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2039 /* .vendor_name = "M-Audio", */ 2040 /* .product_name = "Ozone Academic", */ 2041 .ifnum = QUIRK_ANY_INTERFACE, 2042 .type = QUIRK_COMPOSITE, 2043 .data = & (const struct snd_usb_audio_quirk[]) { 2044 { 2045 .ifnum = 0, 2046 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2047 }, 2048 { 2049 .ifnum = 1, 2050 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2051 }, 2052 { 2053 .ifnum = 2, 2054 .type = QUIRK_AUDIO_STANDARD_INTERFACE 2055 }, 2056 { 2057 .ifnum = 3, 2058 .type = QUIRK_MIDI_MIDIMAN, 2059 .data = & (const struct snd_usb_midi_endpoint_info) { 2060 .out_cables = 0x0001, 2061 .in_cables = 0x0001 2062 } 2063 }, 2064 { 2065 .ifnum = -1 2066 } 2067 } 2068 } 2069 }, 2070 { 2071 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080), 2072 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2073 /* .vendor_name = "M-Audio", */ 2074 /* .product_name = "Fast Track Ultra", */ 2075 .ifnum = QUIRK_ANY_INTERFACE, 2076 .type = QUIRK_COMPOSITE, 2077 .data = & (const struct snd_usb_audio_quirk[]) { 2078 { 2079 .ifnum = 0, 2080 .type = QUIRK_AUDIO_STANDARD_MIXER, 2081 }, 2082 { 2083 .ifnum = 1, 2084 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2085 .data = & (const struct audioformat) { 2086 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2087 .channels = 8, 2088 .iface = 1, 2089 .altsetting = 1, 2090 .altset_idx = 1, 2091 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2092 .endpoint = 0x01, 2093 .ep_attr = 0x09, 2094 .rates = SNDRV_PCM_RATE_44100 | 2095 SNDRV_PCM_RATE_48000 | 2096 SNDRV_PCM_RATE_88200 | 2097 SNDRV_PCM_RATE_96000, 2098 .rate_min = 44100, 2099 .rate_max = 96000, 2100 .nr_rates = 4, 2101 .rate_table = (unsigned int[]) { 2102 44100, 48000, 88200, 96000 2103 } 2104 } 2105 }, 2106 { 2107 .ifnum = 2, 2108 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2109 .data = & (const struct audioformat) { 2110 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2111 .channels = 8, 2112 .iface = 2, 2113 .altsetting = 1, 2114 .altset_idx = 1, 2115 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2116 .endpoint = 0x81, 2117 .ep_attr = 0x05, 2118 .rates = SNDRV_PCM_RATE_44100 | 2119 SNDRV_PCM_RATE_48000 | 2120 SNDRV_PCM_RATE_88200 | 2121 SNDRV_PCM_RATE_96000, 2122 .rate_min = 44100, 2123 .rate_max = 96000, 2124 .nr_rates = 4, 2125 .rate_table = (unsigned int[]) { 2126 44100, 48000, 88200, 96000 2127 } 2128 } 2129 }, 2130 /* interface 3 (MIDI) is standard compliant */ 2131 { 2132 .ifnum = -1 2133 } 2134 } 2135 } 2136 }, 2137 { 2138 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081), 2139 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2140 /* .vendor_name = "M-Audio", */ 2141 /* .product_name = "Fast Track Ultra 8R", */ 2142 .ifnum = QUIRK_ANY_INTERFACE, 2143 .type = QUIRK_COMPOSITE, 2144 .data = & (const struct snd_usb_audio_quirk[]) { 2145 { 2146 .ifnum = 0, 2147 .type = QUIRK_AUDIO_STANDARD_MIXER, 2148 }, 2149 { 2150 .ifnum = 1, 2151 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2152 .data = & (const struct audioformat) { 2153 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2154 .channels = 8, 2155 .iface = 1, 2156 .altsetting = 1, 2157 .altset_idx = 1, 2158 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2159 .endpoint = 0x01, 2160 .ep_attr = 0x09, 2161 .rates = SNDRV_PCM_RATE_44100 | 2162 SNDRV_PCM_RATE_48000 | 2163 SNDRV_PCM_RATE_88200 | 2164 SNDRV_PCM_RATE_96000, 2165 .rate_min = 44100, 2166 .rate_max = 96000, 2167 .nr_rates = 4, 2168 .rate_table = (unsigned int[]) { 2169 44100, 48000, 88200, 96000 2170 } 2171 } 2172 }, 2173 { 2174 .ifnum = 2, 2175 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2176 .data = & (const struct audioformat) { 2177 .formats = SNDRV_PCM_FMTBIT_S24_3LE, 2178 .channels = 8, 2179 .iface = 2, 2180 .altsetting = 1, 2181 .altset_idx = 1, 2182 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2183 .endpoint = 0x81, 2184 .ep_attr = 0x05, 2185 .rates = SNDRV_PCM_RATE_44100 | 2186 SNDRV_PCM_RATE_48000 | 2187 SNDRV_PCM_RATE_88200 | 2188 SNDRV_PCM_RATE_96000, 2189 .rate_min = 44100, 2190 .rate_max = 96000, 2191 .nr_rates = 4, 2192 .rate_table = (unsigned int[]) { 2193 44100, 48000, 88200, 96000 2194 } 2195 } 2196 }, 2197 /* interface 3 (MIDI) is standard compliant */ 2198 { 2199 .ifnum = -1 2200 } 2201 } 2202 } 2203 }, 2204 2205 /* Casio devices */ 2206 { 2207 USB_DEVICE(0x07cf, 0x6801), 2208 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2209 .vendor_name = "Casio", 2210 .product_name = "PL-40R", 2211 .ifnum = 0, 2212 .type = QUIRK_MIDI_YAMAHA 2213 } 2214 }, 2215 { 2216 /* this ID is used by several devices without a product ID */ 2217 USB_DEVICE(0x07cf, 0x6802), 2218 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2219 .vendor_name = "Casio", 2220 .product_name = "Keyboard", 2221 .ifnum = 0, 2222 .type = QUIRK_MIDI_YAMAHA 2223 } 2224 }, 2225 2226 /* Mark of the Unicorn devices */ 2227 { 2228 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 2229 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 2230 USB_DEVICE_ID_MATCH_PRODUCT | 2231 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 2232 .idVendor = 0x07fd, 2233 .idProduct = 0x0001, 2234 .bDeviceSubClass = 2, 2235 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2236 .vendor_name = "MOTU", 2237 .product_name = "Fastlane", 2238 .ifnum = QUIRK_ANY_INTERFACE, 2239 .type = QUIRK_COMPOSITE, 2240 .data = & (const struct snd_usb_audio_quirk[]) { 2241 { 2242 .ifnum = 0, 2243 .type = QUIRK_MIDI_RAW_BYTES 2244 }, 2245 { 2246 .ifnum = 1, 2247 .type = QUIRK_IGNORE_INTERFACE 2248 }, 2249 { 2250 .ifnum = -1 2251 } 2252 } 2253 } 2254 }, 2255 2256 /* Emagic devices */ 2257 { 2258 USB_DEVICE(0x086a, 0x0001), 2259 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2260 .vendor_name = "Emagic", 2261 /* .product_name = "Unitor8", */ 2262 .ifnum = 2, 2263 .type = QUIRK_MIDI_EMAGIC, 2264 .data = & (const struct snd_usb_midi_endpoint_info) { 2265 .out_cables = 0x80ff, 2266 .in_cables = 0x80ff 2267 } 2268 } 2269 }, 2270 { 2271 USB_DEVICE(0x086a, 0x0002), 2272 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2273 .vendor_name = "Emagic", 2274 /* .product_name = "AMT8", */ 2275 .ifnum = 2, 2276 .type = QUIRK_MIDI_EMAGIC, 2277 .data = & (const struct snd_usb_midi_endpoint_info) { 2278 .out_cables = 0x80ff, 2279 .in_cables = 0x80ff 2280 } 2281 } 2282 }, 2283 { 2284 USB_DEVICE(0x086a, 0x0003), 2285 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2286 .vendor_name = "Emagic", 2287 /* .product_name = "MT4", */ 2288 .ifnum = 2, 2289 .type = QUIRK_MIDI_EMAGIC, 2290 .data = & (const struct snd_usb_midi_endpoint_info) { 2291 .out_cables = 0x800f, 2292 .in_cables = 0x8003 2293 } 2294 } 2295 }, 2296 2297 /* KORG devices */ 2298 { 2299 USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200), 2300 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2301 .vendor_name = "KORG, Inc.", 2302 /* .product_name = "PANDORA PX5D", */ 2303 .ifnum = 3, 2304 .type = QUIRK_MIDI_STANDARD_INTERFACE, 2305 } 2306 }, 2307 2308 /* AKAI devices */ 2309 { 2310 USB_DEVICE(0x09e8, 0x0062), 2311 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2312 .vendor_name = "AKAI", 2313 .product_name = "MPD16", 2314 .ifnum = 0, 2315 .type = QUIRK_MIDI_AKAI, 2316 } 2317 }, 2318 2319 /* TerraTec devices */ 2320 { 2321 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 2322 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2323 .vendor_name = "TerraTec", 2324 .product_name = "PHASE 26", 2325 .ifnum = 3, 2326 .type = QUIRK_MIDI_STANDARD_INTERFACE 2327 } 2328 }, 2329 { 2330 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 2331 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2332 .vendor_name = "TerraTec", 2333 .product_name = "PHASE 26", 2334 .ifnum = 3, 2335 .type = QUIRK_MIDI_STANDARD_INTERFACE 2336 } 2337 }, 2338 { 2339 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 2340 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2341 .vendor_name = "TerraTec", 2342 .product_name = "PHASE 26", 2343 .ifnum = 3, 2344 .type = QUIRK_MIDI_STANDARD_INTERFACE 2345 } 2346 }, 2347 { 2348 USB_DEVICE(0x0ccd, 0x0028), 2349 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2350 .vendor_name = "TerraTec", 2351 .product_name = "Aureon5.1MkII", 2352 .ifnum = QUIRK_NO_INTERFACE 2353 } 2354 }, 2355 { 2356 USB_DEVICE(0x0ccd, 0x0035), 2357 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2358 .vendor_name = "Miditech", 2359 .product_name = "Play'n Roll", 2360 .ifnum = 0, 2361 .type = QUIRK_MIDI_CME 2362 } 2363 }, 2364 2365 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ 2366 { 2367 USB_DEVICE(0x103d, 0x0100), 2368 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2369 .vendor_name = "Stanton", 2370 .product_name = "ScratchAmp", 2371 .ifnum = QUIRK_NO_INTERFACE 2372 } 2373 }, 2374 { 2375 USB_DEVICE(0x103d, 0x0101), 2376 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2377 .vendor_name = "Stanton", 2378 .product_name = "ScratchAmp", 2379 .ifnum = QUIRK_NO_INTERFACE 2380 } 2381 }, 2382 2383 /* Novation EMS devices */ 2384 { 2385 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 2386 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2387 .vendor_name = "Novation", 2388 .product_name = "ReMOTE Audio/XStation", 2389 .ifnum = 4, 2390 .type = QUIRK_MIDI_NOVATION 2391 } 2392 }, 2393 { 2394 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 2395 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2396 .vendor_name = "Novation", 2397 .product_name = "Speedio", 2398 .ifnum = 3, 2399 .type = QUIRK_MIDI_NOVATION 2400 } 2401 }, 2402 { 2403 USB_DEVICE(0x1235, 0x000e), 2404 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2405 /* .vendor_name = "Novation", */ 2406 /* .product_name = "Launchpad", */ 2407 .ifnum = 0, 2408 .type = QUIRK_MIDI_RAW_BYTES 2409 } 2410 }, 2411 { 2412 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 2413 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2414 .vendor_name = "Novation", 2415 .product_name = "ReMOTE25", 2416 .ifnum = 0, 2417 .type = QUIRK_MIDI_NOVATION 2418 } 2419 }, 2420 2421 /* Access Music devices */ 2422 { 2423 /* VirusTI Desktop */ 2424 USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815), 2425 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2426 .ifnum = QUIRK_ANY_INTERFACE, 2427 .type = QUIRK_COMPOSITE, 2428 .data = &(const struct snd_usb_audio_quirk[]) { 2429 { 2430 .ifnum = 3, 2431 .type = QUIRK_MIDI_FIXED_ENDPOINT, 2432 .data = &(const struct snd_usb_midi_endpoint_info) { 2433 .out_cables = 0x0003, 2434 .in_cables = 0x0003 2435 } 2436 }, 2437 { 2438 .ifnum = 4, 2439 .type = QUIRK_IGNORE_INTERFACE 2440 }, 2441 { 2442 .ifnum = -1 2443 } 2444 } 2445 } 2446 }, 2447 2448 /* */ 2449 { 2450 /* aka. Serato Scratch Live DJ Box */ 2451 USB_DEVICE(0x13e5, 0x0001), 2452 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2453 .vendor_name = "Rane", 2454 .product_name = "SL-1", 2455 .ifnum = QUIRK_NO_INTERFACE 2456 } 2457 }, 2458 2459 /* Native Instruments MK2 series */ 2460 { 2461 /* Komplete Audio 6 */ 2462 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2463 .idVendor = 0x17cc, 2464 .idProduct = 0x1000, 2465 }, 2466 { 2467 /* Traktor Audio 6 */ 2468 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2469 .idVendor = 0x17cc, 2470 .idProduct = 0x1010, 2471 }, 2472 { 2473 /* Traktor Audio 10 */ 2474 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 2475 .idVendor = 0x17cc, 2476 .idProduct = 0x1020, 2477 }, 2478 2479 /* KeithMcMillen Stringport */ 2480 { 2481 USB_DEVICE(0x1f38, 0x0001), 2482 .bInterfaceClass = USB_CLASS_AUDIO, 2483 }, 2484 2485 /* Miditech devices */ 2486 { 2487 USB_DEVICE(0x4752, 0x0011), 2488 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2489 .vendor_name = "Miditech", 2490 .product_name = "Midistart-2", 2491 .ifnum = 0, 2492 .type = QUIRK_MIDI_CME 2493 } 2494 }, 2495 2496 /* Central Music devices */ 2497 { 2498 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2499 USB_DEVICE(0x7104, 0x2202), 2500 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2501 .ifnum = 0, 2502 .type = QUIRK_MIDI_CME 2503 } 2504 }, 2505 2506 /* Hauppauge HVR-950Q and HVR-850 */ 2507 { 2508 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7200), 2509 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2510 USB_DEVICE_ID_MATCH_INT_CLASS | 2511 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2512 .bInterfaceClass = USB_CLASS_AUDIO, 2513 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2514 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2515 .vendor_name = "Hauppauge", 2516 .product_name = "HVR-950Q", 2517 .ifnum = QUIRK_ANY_INTERFACE, 2518 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2519 } 2520 }, 2521 { 2522 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7240), 2523 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2524 USB_DEVICE_ID_MATCH_INT_CLASS | 2525 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2526 .bInterfaceClass = USB_CLASS_AUDIO, 2527 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2528 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2529 .vendor_name = "Hauppauge", 2530 .product_name = "HVR-850", 2531 .ifnum = QUIRK_ANY_INTERFACE, 2532 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2533 } 2534 }, 2535 { 2536 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7210), 2537 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2538 USB_DEVICE_ID_MATCH_INT_CLASS | 2539 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2540 .bInterfaceClass = USB_CLASS_AUDIO, 2541 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2542 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2543 .vendor_name = "Hauppauge", 2544 .product_name = "HVR-950Q", 2545 .ifnum = QUIRK_ANY_INTERFACE, 2546 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2547 } 2548 }, 2549 { 2550 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7217), 2551 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2552 USB_DEVICE_ID_MATCH_INT_CLASS | 2553 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2554 .bInterfaceClass = USB_CLASS_AUDIO, 2555 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2556 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2557 .vendor_name = "Hauppauge", 2558 .product_name = "HVR-950Q", 2559 .ifnum = QUIRK_ANY_INTERFACE, 2560 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2561 } 2562 }, 2563 { 2564 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721b), 2565 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2566 USB_DEVICE_ID_MATCH_INT_CLASS | 2567 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2568 .bInterfaceClass = USB_CLASS_AUDIO, 2569 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2570 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2571 .vendor_name = "Hauppauge", 2572 .product_name = "HVR-950Q", 2573 .ifnum = QUIRK_ANY_INTERFACE, 2574 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2575 } 2576 }, 2577 { 2578 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721e), 2579 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2580 USB_DEVICE_ID_MATCH_INT_CLASS | 2581 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2582 .bInterfaceClass = USB_CLASS_AUDIO, 2583 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2584 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2585 .vendor_name = "Hauppauge", 2586 .product_name = "HVR-950Q", 2587 .ifnum = QUIRK_ANY_INTERFACE, 2588 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2589 } 2590 }, 2591 { 2592 USB_DEVICE_VENDOR_SPEC(0x2040, 0x721f), 2593 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2594 USB_DEVICE_ID_MATCH_INT_CLASS | 2595 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2596 .bInterfaceClass = USB_CLASS_AUDIO, 2597 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2598 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2599 .vendor_name = "Hauppauge", 2600 .product_name = "HVR-950Q", 2601 .ifnum = QUIRK_ANY_INTERFACE, 2602 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2603 } 2604 }, 2605 { 2606 USB_DEVICE_VENDOR_SPEC(0x2040, 0x7280), 2607 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2608 USB_DEVICE_ID_MATCH_INT_CLASS | 2609 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2610 .bInterfaceClass = USB_CLASS_AUDIO, 2611 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2612 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2613 .vendor_name = "Hauppauge", 2614 .product_name = "HVR-950Q", 2615 .ifnum = QUIRK_ANY_INTERFACE, 2616 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2617 } 2618 }, 2619 { 2620 USB_DEVICE_VENDOR_SPEC(0x0fd9, 0x0008), 2621 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 2622 USB_DEVICE_ID_MATCH_INT_CLASS | 2623 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2624 .bInterfaceClass = USB_CLASS_AUDIO, 2625 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 2626 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2627 .vendor_name = "Hauppauge", 2628 .product_name = "HVR-950Q", 2629 .ifnum = QUIRK_ANY_INTERFACE, 2630 .type = QUIRK_AUDIO_ALIGN_TRANSFER, 2631 } 2632 }, 2633 2634 /* Digidesign Mbox */ 2635 { 2636 /* Thanks to Clemens Ladisch <clemens@ladisch.de> */ 2637 USB_DEVICE(0x0dba, 0x1000), 2638 .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { 2639 .vendor_name = "Digidesign", 2640 .product_name = "MBox", 2641 .ifnum = QUIRK_ANY_INTERFACE, 2642 .type = QUIRK_COMPOSITE, 2643 .data = (const struct snd_usb_audio_quirk[]){ 2644 { 2645 .ifnum = 0, 2646 .type = QUIRK_IGNORE_INTERFACE, 2647 }, 2648 { 2649 .ifnum = 1, 2650 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 2651 .data = &(const struct audioformat) { 2652 .formats = SNDRV_PCM_FMTBIT_S24_3BE, 2653 .channels = 2, 2654 .iface = 1, 2655 .altsetting = 1, 2656 .altset_idx = 1, 2657 .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, 2658 .endpoint = 0x02, 2659 .ep_attr = 0x01, 2660 .maxpacksize = 0x130, 2661 .rates = SNDRV_PCM_RATE_44100 | 2662 SNDRV_PCM_RATE_48000, 2663 .rate_min = 44100, 2664 .rate_max = 48000, 2665 .nr_rates = 2, 2666 .rate_table = (unsigned int[]) { 2667 44100, 48000 2668 } 2669 } 2670 }, 2671 { 2672 .ifnum = -1 2673 } 2674 } 2675 2676 } 2677 }, 2678 2679 { 2680 /* 2681 * Some USB MIDI devices don't have an audio control interface, 2682 * so we have to grab MIDI streaming interfaces here. 2683 */ 2684 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 2685 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2686 .bInterfaceClass = USB_CLASS_AUDIO, 2687 .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING, 2688 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2689 .ifnum = QUIRK_ANY_INTERFACE, 2690 .type = QUIRK_MIDI_STANDARD_INTERFACE 2691 } 2692 }, 2693 2694 #undef USB_DEVICE_VENDOR_SPEC 2695