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 /* Creative/E-Mu devices */ 43 { 44 USB_DEVICE(0x041e, 0x3010), 45 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 46 .vendor_name = "Creative Labs", 47 .product_name = "Sound Blaster MP3+", 48 .ifnum = QUIRK_NO_INTERFACE 49 } 50 }, 51 { 52 /* E-Mu 0202 USB */ 53 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 54 .idVendor = 0x041e, 55 .idProduct = 0x3f02, 56 .bInterfaceClass = USB_CLASS_AUDIO, 57 }, 58 { 59 /* E-Mu 0404 USB */ 60 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 61 .idVendor = 0x041e, 62 .idProduct = 0x3f04, 63 .bInterfaceClass = USB_CLASS_AUDIO, 64 }, 65 { 66 /* E-Mu Tracker Pre */ 67 .match_flags = USB_DEVICE_ID_MATCH_DEVICE, 68 .idVendor = 0x041e, 69 .idProduct = 0x3f0a, 70 .bInterfaceClass = USB_CLASS_AUDIO, 71 }, 72 73 /* 74 * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface 75 * class matches do not take effect without an explicit ID match. 76 */ 77 { 78 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 79 USB_DEVICE_ID_MATCH_INT_CLASS | 80 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 81 .idVendor = 0x046d, 82 .idProduct = 0x0850, 83 .bInterfaceClass = USB_CLASS_AUDIO, 84 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL 85 }, 86 { 87 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 88 USB_DEVICE_ID_MATCH_INT_CLASS | 89 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 90 .idVendor = 0x046d, 91 .idProduct = 0x08ae, 92 .bInterfaceClass = USB_CLASS_AUDIO, 93 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL 94 }, 95 { 96 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 97 USB_DEVICE_ID_MATCH_INT_CLASS | 98 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 99 .idVendor = 0x046d, 100 .idProduct = 0x08c6, 101 .bInterfaceClass = USB_CLASS_AUDIO, 102 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL 103 }, 104 { 105 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 106 USB_DEVICE_ID_MATCH_INT_CLASS | 107 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 108 .idVendor = 0x046d, 109 .idProduct = 0x08f0, 110 .bInterfaceClass = USB_CLASS_AUDIO, 111 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL 112 }, 113 { 114 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 115 USB_DEVICE_ID_MATCH_INT_CLASS | 116 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 117 .idVendor = 0x046d, 118 .idProduct = 0x08f5, 119 .bInterfaceClass = USB_CLASS_AUDIO, 120 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL 121 }, 122 { 123 .match_flags = USB_DEVICE_ID_MATCH_DEVICE | 124 USB_DEVICE_ID_MATCH_INT_CLASS | 125 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 126 .idVendor = 0x046d, 127 .idProduct = 0x08f6, 128 .bInterfaceClass = USB_CLASS_AUDIO, 129 .bInterfaceSubClass = USB_SUBCLASS_AUDIO_CONTROL 130 }, 131 { 132 USB_DEVICE(0x046d, 0x0990), 133 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 134 .vendor_name = "Logitech, Inc.", 135 .product_name = "QuickCam Pro 9000", 136 .ifnum = QUIRK_NO_INTERFACE 137 } 138 }, 139 140 /* 141 * Yamaha devices 142 */ 143 144 #define YAMAHA_DEVICE(id, name) { \ 145 USB_DEVICE(0x0499, id), \ 146 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ 147 .vendor_name = "Yamaha", \ 148 .product_name = name, \ 149 .ifnum = QUIRK_ANY_INTERFACE, \ 150 .type = QUIRK_MIDI_YAMAHA \ 151 } \ 152 } 153 #define YAMAHA_INTERFACE(id, intf, name) { \ 154 USB_DEVICE_VENDOR_SPEC(0x0499, id), \ 155 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \ 156 .vendor_name = "Yamaha", \ 157 .product_name = name, \ 158 .ifnum = intf, \ 159 .type = QUIRK_MIDI_YAMAHA \ 160 } \ 161 } 162 YAMAHA_DEVICE(0x1000, "UX256"), 163 YAMAHA_DEVICE(0x1001, "MU1000"), 164 YAMAHA_DEVICE(0x1002, "MU2000"), 165 YAMAHA_DEVICE(0x1003, "MU500"), 166 YAMAHA_INTERFACE(0x1004, 3, "UW500"), 167 YAMAHA_DEVICE(0x1005, "MOTIF6"), 168 YAMAHA_DEVICE(0x1006, "MOTIF7"), 169 YAMAHA_DEVICE(0x1007, "MOTIF8"), 170 YAMAHA_DEVICE(0x1008, "UX96"), 171 YAMAHA_DEVICE(0x1009, "UX16"), 172 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"), 173 YAMAHA_DEVICE(0x100c, "UC-MX"), 174 YAMAHA_DEVICE(0x100d, "UC-KX"), 175 YAMAHA_DEVICE(0x100e, "S08"), 176 YAMAHA_DEVICE(0x100f, "CLP-150"), 177 YAMAHA_DEVICE(0x1010, "CLP-170"), 178 YAMAHA_DEVICE(0x1011, "P-250"), 179 YAMAHA_DEVICE(0x1012, "TYROS"), 180 YAMAHA_DEVICE(0x1013, "PF-500"), 181 YAMAHA_DEVICE(0x1014, "S90"), 182 YAMAHA_DEVICE(0x1015, "MOTIF-R"), 183 YAMAHA_DEVICE(0x1016, "MDP-5"), 184 YAMAHA_DEVICE(0x1017, "CVP-204"), 185 YAMAHA_DEVICE(0x1018, "CVP-206"), 186 YAMAHA_DEVICE(0x1019, "CVP-208"), 187 YAMAHA_DEVICE(0x101a, "CVP-210"), 188 YAMAHA_DEVICE(0x101b, "PSR-1100"), 189 YAMAHA_DEVICE(0x101c, "PSR-2100"), 190 YAMAHA_DEVICE(0x101d, "CLP-175"), 191 YAMAHA_DEVICE(0x101e, "PSR-K1"), 192 YAMAHA_DEVICE(0x101f, "EZ-J24"), 193 YAMAHA_DEVICE(0x1020, "EZ-250i"), 194 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"), 195 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"), 196 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"), 197 YAMAHA_DEVICE(0x1024, "CVP-301"), 198 YAMAHA_DEVICE(0x1025, "CVP-303"), 199 YAMAHA_DEVICE(0x1026, "CVP-305"), 200 YAMAHA_DEVICE(0x1027, "CVP-307"), 201 YAMAHA_DEVICE(0x1028, "CVP-309"), 202 YAMAHA_DEVICE(0x1029, "CVP-309GP"), 203 YAMAHA_DEVICE(0x102a, "PSR-1500"), 204 YAMAHA_DEVICE(0x102b, "PSR-3000"), 205 YAMAHA_DEVICE(0x102e, "ELS-01/01C"), 206 YAMAHA_DEVICE(0x1030, "PSR-295/293"), 207 YAMAHA_DEVICE(0x1031, "DGX-205/203"), 208 YAMAHA_DEVICE(0x1032, "DGX-305"), 209 YAMAHA_DEVICE(0x1033, "DGX-505"), 210 YAMAHA_DEVICE(0x1034, NULL), 211 YAMAHA_DEVICE(0x1035, NULL), 212 YAMAHA_DEVICE(0x1036, NULL), 213 YAMAHA_DEVICE(0x1037, NULL), 214 YAMAHA_DEVICE(0x1038, NULL), 215 YAMAHA_DEVICE(0x1039, NULL), 216 YAMAHA_DEVICE(0x103a, NULL), 217 YAMAHA_DEVICE(0x103b, NULL), 218 YAMAHA_DEVICE(0x103c, NULL), 219 YAMAHA_DEVICE(0x103d, NULL), 220 YAMAHA_DEVICE(0x103e, NULL), 221 YAMAHA_DEVICE(0x103f, NULL), 222 YAMAHA_DEVICE(0x1040, NULL), 223 YAMAHA_DEVICE(0x1041, NULL), 224 YAMAHA_DEVICE(0x1042, NULL), 225 YAMAHA_DEVICE(0x1043, NULL), 226 YAMAHA_DEVICE(0x1044, NULL), 227 YAMAHA_DEVICE(0x1045, NULL), 228 YAMAHA_INTERFACE(0x104e, 0, NULL), 229 YAMAHA_DEVICE(0x104f, NULL), 230 YAMAHA_DEVICE(0x1050, NULL), 231 YAMAHA_DEVICE(0x1051, NULL), 232 YAMAHA_DEVICE(0x1052, NULL), 233 YAMAHA_DEVICE(0x2000, "DGP-7"), 234 YAMAHA_DEVICE(0x2001, "DGP-5"), 235 YAMAHA_DEVICE(0x2002, NULL), 236 YAMAHA_DEVICE(0x5000, "CS1D"), 237 YAMAHA_DEVICE(0x5001, "DSP1D"), 238 YAMAHA_DEVICE(0x5002, "DME32"), 239 YAMAHA_DEVICE(0x5003, "DM2000"), 240 YAMAHA_DEVICE(0x5004, "02R96"), 241 YAMAHA_DEVICE(0x5005, "ACU16-C"), 242 YAMAHA_DEVICE(0x5006, "NHB32-C"), 243 YAMAHA_DEVICE(0x5007, "DM1000"), 244 YAMAHA_DEVICE(0x5008, "01V96"), 245 YAMAHA_DEVICE(0x5009, "SPX2000"), 246 YAMAHA_DEVICE(0x500a, "PM5D"), 247 YAMAHA_DEVICE(0x500b, "DME64N"), 248 YAMAHA_DEVICE(0x500c, "DME24N"), 249 YAMAHA_DEVICE(0x500d, NULL), 250 YAMAHA_DEVICE(0x500e, NULL), 251 YAMAHA_DEVICE(0x500f, NULL), 252 YAMAHA_DEVICE(0x7000, "DTX"), 253 YAMAHA_DEVICE(0x7010, "UB99"), 254 #undef YAMAHA_DEVICE 255 #undef YAMAHA_INTERFACE 256 257 /* 258 * Roland/RolandED/Edirol/BOSS devices 259 */ 260 { 261 USB_DEVICE(0x0582, 0x0000), 262 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 263 .vendor_name = "Roland", 264 .product_name = "UA-100", 265 .ifnum = QUIRK_ANY_INTERFACE, 266 .type = QUIRK_COMPOSITE, 267 .data = (const struct snd_usb_audio_quirk[]) { 268 { 269 .ifnum = 0, 270 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 271 .data = & (const struct audioformat) { 272 .format = SNDRV_PCM_FORMAT_S16_LE, 273 .channels = 4, 274 .iface = 0, 275 .altsetting = 1, 276 .altset_idx = 1, 277 .attributes = 0, 278 .endpoint = 0x01, 279 .ep_attr = 0x09, 280 .rates = SNDRV_PCM_RATE_CONTINUOUS, 281 .rate_min = 44100, 282 .rate_max = 44100, 283 } 284 }, 285 { 286 .ifnum = 1, 287 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 288 .data = & (const struct audioformat) { 289 .format = SNDRV_PCM_FORMAT_S16_LE, 290 .channels = 2, 291 .iface = 1, 292 .altsetting = 1, 293 .altset_idx = 1, 294 .attributes = EP_CS_ATTR_FILL_MAX, 295 .endpoint = 0x81, 296 .ep_attr = 0x05, 297 .rates = SNDRV_PCM_RATE_CONTINUOUS, 298 .rate_min = 44100, 299 .rate_max = 44100, 300 } 301 }, 302 { 303 .ifnum = 2, 304 .type = QUIRK_MIDI_FIXED_ENDPOINT, 305 .data = & (const struct snd_usb_midi_endpoint_info) { 306 .out_cables = 0x0007, 307 .in_cables = 0x0007 308 } 309 }, 310 { 311 .ifnum = -1 312 } 313 } 314 } 315 }, 316 { 317 USB_DEVICE(0x0582, 0x0002), 318 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 319 .vendor_name = "EDIROL", 320 .product_name = "UM-4", 321 .ifnum = QUIRK_ANY_INTERFACE, 322 .type = QUIRK_COMPOSITE, 323 .data = (const struct snd_usb_audio_quirk[]) { 324 { 325 .ifnum = 0, 326 .type = QUIRK_IGNORE_INTERFACE 327 }, 328 { 329 .ifnum = 1, 330 .type = QUIRK_IGNORE_INTERFACE 331 }, 332 { 333 .ifnum = 2, 334 .type = QUIRK_MIDI_FIXED_ENDPOINT, 335 .data = & (const struct snd_usb_midi_endpoint_info) { 336 .out_cables = 0x000f, 337 .in_cables = 0x000f 338 } 339 }, 340 { 341 .ifnum = -1 342 } 343 } 344 } 345 }, 346 { 347 USB_DEVICE(0x0582, 0x0003), 348 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 349 .vendor_name = "Roland", 350 .product_name = "SC-8850", 351 .ifnum = QUIRK_ANY_INTERFACE, 352 .type = QUIRK_COMPOSITE, 353 .data = (const struct snd_usb_audio_quirk[]) { 354 { 355 .ifnum = 0, 356 .type = QUIRK_IGNORE_INTERFACE 357 }, 358 { 359 .ifnum = 1, 360 .type = QUIRK_IGNORE_INTERFACE 361 }, 362 { 363 .ifnum = 2, 364 .type = QUIRK_MIDI_FIXED_ENDPOINT, 365 .data = & (const struct snd_usb_midi_endpoint_info) { 366 .out_cables = 0x003f, 367 .in_cables = 0x003f 368 } 369 }, 370 { 371 .ifnum = -1 372 } 373 } 374 } 375 }, 376 { 377 USB_DEVICE(0x0582, 0x0004), 378 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 379 .vendor_name = "Roland", 380 .product_name = "U-8", 381 .ifnum = QUIRK_ANY_INTERFACE, 382 .type = QUIRK_COMPOSITE, 383 .data = (const struct snd_usb_audio_quirk[]) { 384 { 385 .ifnum = 0, 386 .type = QUIRK_IGNORE_INTERFACE 387 }, 388 { 389 .ifnum = 1, 390 .type = QUIRK_IGNORE_INTERFACE 391 }, 392 { 393 .ifnum = 2, 394 .type = QUIRK_MIDI_FIXED_ENDPOINT, 395 .data = & (const struct snd_usb_midi_endpoint_info) { 396 .out_cables = 0x0005, 397 .in_cables = 0x0005 398 } 399 }, 400 { 401 .ifnum = -1 402 } 403 } 404 } 405 }, 406 { 407 /* Has ID 0x0099 when not in "Advanced Driver" mode. 408 * The UM-2EX has only one input, but we cannot detect this. */ 409 USB_DEVICE(0x0582, 0x0005), 410 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 411 .vendor_name = "EDIROL", 412 .product_name = "UM-2", 413 .ifnum = QUIRK_ANY_INTERFACE, 414 .type = QUIRK_COMPOSITE, 415 .data = (const struct snd_usb_audio_quirk[]) { 416 { 417 .ifnum = 0, 418 .type = QUIRK_IGNORE_INTERFACE 419 }, 420 { 421 .ifnum = 1, 422 .type = QUIRK_IGNORE_INTERFACE 423 }, 424 { 425 .ifnum = 2, 426 .type = QUIRK_MIDI_FIXED_ENDPOINT, 427 .data = & (const struct snd_usb_midi_endpoint_info) { 428 .out_cables = 0x0003, 429 .in_cables = 0x0003 430 } 431 }, 432 { 433 .ifnum = -1 434 } 435 } 436 } 437 }, 438 { 439 USB_DEVICE(0x0582, 0x0007), 440 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 441 .vendor_name = "Roland", 442 .product_name = "SC-8820", 443 .ifnum = QUIRK_ANY_INTERFACE, 444 .type = QUIRK_COMPOSITE, 445 .data = (const struct snd_usb_audio_quirk[]) { 446 { 447 .ifnum = 0, 448 .type = QUIRK_IGNORE_INTERFACE 449 }, 450 { 451 .ifnum = 1, 452 .type = QUIRK_IGNORE_INTERFACE 453 }, 454 { 455 .ifnum = 2, 456 .type = QUIRK_MIDI_FIXED_ENDPOINT, 457 .data = & (const struct snd_usb_midi_endpoint_info) { 458 .out_cables = 0x0013, 459 .in_cables = 0x0013 460 } 461 }, 462 { 463 .ifnum = -1 464 } 465 } 466 } 467 }, 468 { 469 USB_DEVICE(0x0582, 0x0008), 470 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 471 .vendor_name = "Roland", 472 .product_name = "PC-300", 473 .ifnum = QUIRK_ANY_INTERFACE, 474 .type = QUIRK_COMPOSITE, 475 .data = (const struct snd_usb_audio_quirk[]) { 476 { 477 .ifnum = 0, 478 .type = QUIRK_IGNORE_INTERFACE 479 }, 480 { 481 .ifnum = 1, 482 .type = QUIRK_IGNORE_INTERFACE 483 }, 484 { 485 .ifnum = 2, 486 .type = QUIRK_MIDI_FIXED_ENDPOINT, 487 .data = & (const struct snd_usb_midi_endpoint_info) { 488 .out_cables = 0x0001, 489 .in_cables = 0x0001 490 } 491 }, 492 { 493 .ifnum = -1 494 } 495 } 496 } 497 }, 498 { 499 /* has ID 0x009d when not in "Advanced Driver" mode */ 500 USB_DEVICE(0x0582, 0x0009), 501 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 502 .vendor_name = "EDIROL", 503 .product_name = "UM-1", 504 .ifnum = QUIRK_ANY_INTERFACE, 505 .type = QUIRK_COMPOSITE, 506 .data = (const struct snd_usb_audio_quirk[]) { 507 { 508 .ifnum = 0, 509 .type = QUIRK_IGNORE_INTERFACE 510 }, 511 { 512 .ifnum = 1, 513 .type = QUIRK_IGNORE_INTERFACE 514 }, 515 { 516 .ifnum = 2, 517 .type = QUIRK_MIDI_FIXED_ENDPOINT, 518 .data = & (const struct snd_usb_midi_endpoint_info) { 519 .out_cables = 0x0001, 520 .in_cables = 0x0001 521 } 522 }, 523 { 524 .ifnum = -1 525 } 526 } 527 } 528 }, 529 { 530 USB_DEVICE(0x0582, 0x000b), 531 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 532 .vendor_name = "Roland", 533 .product_name = "SK-500", 534 .ifnum = QUIRK_ANY_INTERFACE, 535 .type = QUIRK_COMPOSITE, 536 .data = (const struct snd_usb_audio_quirk[]) { 537 { 538 .ifnum = 0, 539 .type = QUIRK_IGNORE_INTERFACE 540 }, 541 { 542 .ifnum = 1, 543 .type = QUIRK_IGNORE_INTERFACE 544 }, 545 { 546 .ifnum = 2, 547 .type = QUIRK_MIDI_FIXED_ENDPOINT, 548 .data = & (const struct snd_usb_midi_endpoint_info) { 549 .out_cables = 0x0013, 550 .in_cables = 0x0013 551 } 552 }, 553 { 554 .ifnum = -1 555 } 556 } 557 } 558 }, 559 { 560 /* thanks to Emiliano Grilli <emillo@libero.it> 561 * for helping researching this data */ 562 USB_DEVICE(0x0582, 0x000c), 563 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 564 .vendor_name = "Roland", 565 .product_name = "SC-D70", 566 .ifnum = QUIRK_ANY_INTERFACE, 567 .type = QUIRK_COMPOSITE, 568 .data = (const struct snd_usb_audio_quirk[]) { 569 { 570 .ifnum = 0, 571 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 572 .data = & (const struct audioformat) { 573 .format = SNDRV_PCM_FORMAT_S24_3LE, 574 .channels = 2, 575 .iface = 0, 576 .altsetting = 1, 577 .altset_idx = 1, 578 .attributes = 0, 579 .endpoint = 0x01, 580 .ep_attr = 0x01, 581 .rates = SNDRV_PCM_RATE_CONTINUOUS, 582 .rate_min = 44100, 583 .rate_max = 44100, 584 } 585 }, 586 { 587 .ifnum = 1, 588 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 589 .data = & (const struct audioformat) { 590 .format = SNDRV_PCM_FORMAT_S24_3LE, 591 .channels = 2, 592 .iface = 1, 593 .altsetting = 1, 594 .altset_idx = 1, 595 .attributes = 0, 596 .endpoint = 0x81, 597 .ep_attr = 0x01, 598 .rates = SNDRV_PCM_RATE_CONTINUOUS, 599 .rate_min = 44100, 600 .rate_max = 44100, 601 } 602 }, 603 { 604 .ifnum = 2, 605 .type = QUIRK_MIDI_FIXED_ENDPOINT, 606 .data = & (const struct snd_usb_midi_endpoint_info) { 607 .out_cables = 0x0007, 608 .in_cables = 0x0007 609 } 610 }, 611 { 612 .ifnum = -1 613 } 614 } 615 } 616 }, 617 { /* 618 * This quirk is for the "Advanced Driver" mode of the Edirol UA-5. 619 * If the advanced mode switch at the back of the unit is off, the 620 * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks), 621 * but offers only 16-bit PCM. 622 * In advanced mode, the UA-5 will output S24_3LE samples (two 623 * channels) at the rate indicated on the front switch, including 624 * the 96kHz sample rate. 625 */ 626 USB_DEVICE(0x0582, 0x0010), 627 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 628 .vendor_name = "EDIROL", 629 .product_name = "UA-5", 630 .ifnum = QUIRK_ANY_INTERFACE, 631 .type = QUIRK_COMPOSITE, 632 .data = (const struct snd_usb_audio_quirk[]) { 633 { 634 .ifnum = 1, 635 .type = QUIRK_AUDIO_STANDARD_INTERFACE 636 }, 637 { 638 .ifnum = 2, 639 .type = QUIRK_AUDIO_STANDARD_INTERFACE 640 }, 641 { 642 .ifnum = -1 643 } 644 } 645 } 646 }, 647 { 648 /* has ID 0x0013 when not in "Advanced Driver" mode */ 649 USB_DEVICE(0x0582, 0x0012), 650 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 651 .vendor_name = "Roland", 652 .product_name = "XV-5050", 653 .ifnum = 0, 654 .type = QUIRK_MIDI_FIXED_ENDPOINT, 655 .data = & (const struct snd_usb_midi_endpoint_info) { 656 .out_cables = 0x0001, 657 .in_cables = 0x0001 658 } 659 } 660 }, 661 { 662 /* has ID 0x0015 when not in "Advanced Driver" mode */ 663 USB_DEVICE(0x0582, 0x0014), 664 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 665 .vendor_name = "EDIROL", 666 .product_name = "UM-880", 667 .ifnum = 0, 668 .type = QUIRK_MIDI_FIXED_ENDPOINT, 669 .data = & (const struct snd_usb_midi_endpoint_info) { 670 .out_cables = 0x01ff, 671 .in_cables = 0x01ff 672 } 673 } 674 }, 675 { 676 /* has ID 0x0017 when not in "Advanced Driver" mode */ 677 USB_DEVICE(0x0582, 0x0016), 678 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 679 .vendor_name = "EDIROL", 680 .product_name = "SD-90", 681 .ifnum = QUIRK_ANY_INTERFACE, 682 .type = QUIRK_COMPOSITE, 683 .data = (const struct snd_usb_audio_quirk[]) { 684 { 685 .ifnum = 0, 686 .type = QUIRK_IGNORE_INTERFACE 687 }, 688 { 689 .ifnum = 1, 690 .type = QUIRK_IGNORE_INTERFACE 691 }, 692 { 693 .ifnum = 2, 694 .type = QUIRK_MIDI_FIXED_ENDPOINT, 695 .data = & (const struct snd_usb_midi_endpoint_info) { 696 .out_cables = 0x000f, 697 .in_cables = 0x000f 698 } 699 }, 700 { 701 .ifnum = -1 702 } 703 } 704 } 705 }, 706 { 707 /* has ID 0x001c when not in "Advanced Driver" mode */ 708 USB_DEVICE(0x0582, 0x001b), 709 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 710 .vendor_name = "Roland", 711 .product_name = "MMP-2", 712 .ifnum = QUIRK_ANY_INTERFACE, 713 .type = QUIRK_COMPOSITE, 714 .data = (const struct snd_usb_audio_quirk[]) { 715 { 716 .ifnum = 0, 717 .type = QUIRK_IGNORE_INTERFACE 718 }, 719 { 720 .ifnum = 1, 721 .type = QUIRK_IGNORE_INTERFACE 722 }, 723 { 724 .ifnum = 2, 725 .type = QUIRK_MIDI_FIXED_ENDPOINT, 726 .data = & (const struct snd_usb_midi_endpoint_info) { 727 .out_cables = 0x0001, 728 .in_cables = 0x0001 729 } 730 }, 731 { 732 .ifnum = -1 733 } 734 } 735 } 736 }, 737 { 738 /* has ID 0x001e when not in "Advanced Driver" mode */ 739 USB_DEVICE(0x0582, 0x001d), 740 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 741 .vendor_name = "Roland", 742 .product_name = "V-SYNTH", 743 .ifnum = 0, 744 .type = QUIRK_MIDI_FIXED_ENDPOINT, 745 .data = & (const struct snd_usb_midi_endpoint_info) { 746 .out_cables = 0x0001, 747 .in_cables = 0x0001 748 } 749 } 750 }, 751 { 752 /* has ID 0x0024 when not in "Advanced Driver" mode */ 753 USB_DEVICE(0x0582, 0x0023), 754 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 755 .vendor_name = "EDIROL", 756 .product_name = "UM-550", 757 .ifnum = 0, 758 .type = QUIRK_MIDI_FIXED_ENDPOINT, 759 .data = & (const struct snd_usb_midi_endpoint_info) { 760 .out_cables = 0x003f, 761 .in_cables = 0x003f 762 } 763 } 764 }, 765 { 766 /* 767 * This quirk is for the "Advanced Driver" mode. If off, the UA-20 768 * has ID 0x0026 and is standard compliant, but has only 16-bit PCM 769 * and no MIDI. 770 */ 771 USB_DEVICE(0x0582, 0x0025), 772 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 773 .vendor_name = "EDIROL", 774 .product_name = "UA-20", 775 .ifnum = QUIRK_ANY_INTERFACE, 776 .type = QUIRK_COMPOSITE, 777 .data = (const struct snd_usb_audio_quirk[]) { 778 { 779 .ifnum = 0, 780 .type = QUIRK_IGNORE_INTERFACE 781 }, 782 { 783 .ifnum = 1, 784 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 785 .data = & (const struct audioformat) { 786 .format = SNDRV_PCM_FORMAT_S24_3LE, 787 .channels = 2, 788 .iface = 1, 789 .altsetting = 1, 790 .altset_idx = 1, 791 .attributes = 0, 792 .endpoint = 0x01, 793 .ep_attr = 0x01, 794 .rates = SNDRV_PCM_RATE_CONTINUOUS, 795 .rate_min = 44100, 796 .rate_max = 44100, 797 } 798 }, 799 { 800 .ifnum = 2, 801 .type = QUIRK_AUDIO_FIXED_ENDPOINT, 802 .data = & (const struct audioformat) { 803 .format = SNDRV_PCM_FORMAT_S24_3LE, 804 .channels = 2, 805 .iface = 2, 806 .altsetting = 1, 807 .altset_idx = 1, 808 .attributes = 0, 809 .endpoint = 0x82, 810 .ep_attr = 0x01, 811 .rates = SNDRV_PCM_RATE_CONTINUOUS, 812 .rate_min = 44100, 813 .rate_max = 44100, 814 } 815 }, 816 { 817 .ifnum = 3, 818 .type = QUIRK_MIDI_FIXED_ENDPOINT, 819 .data = & (const struct snd_usb_midi_endpoint_info) { 820 .out_cables = 0x0001, 821 .in_cables = 0x0001 822 } 823 }, 824 { 825 .ifnum = -1 826 } 827 } 828 } 829 }, 830 { 831 /* has ID 0x0028 when not in "Advanced Driver" mode */ 832 USB_DEVICE(0x0582, 0x0027), 833 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 834 .vendor_name = "EDIROL", 835 .product_name = "SD-20", 836 .ifnum = 0, 837 .type = QUIRK_MIDI_FIXED_ENDPOINT, 838 .data = & (const struct snd_usb_midi_endpoint_info) { 839 .out_cables = 0x0003, 840 .in_cables = 0x0007 841 } 842 } 843 }, 844 { 845 /* has ID 0x002a when not in "Advanced Driver" mode */ 846 USB_DEVICE(0x0582, 0x0029), 847 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 848 .vendor_name = "EDIROL", 849 .product_name = "SD-80", 850 .ifnum = 0, 851 .type = QUIRK_MIDI_FIXED_ENDPOINT, 852 .data = & (const struct snd_usb_midi_endpoint_info) { 853 .out_cables = 0x000f, 854 .in_cables = 0x000f 855 } 856 } 857 }, 858 { /* 859 * This quirk is for the "Advanced" modes of the Edirol UA-700. 860 * If the sample format switch is not in an advanced setting, the 861 * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks), 862 * but offers only 16-bit PCM and no MIDI. 863 */ 864 USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b), 865 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 866 .vendor_name = "EDIROL", 867 .product_name = "UA-700", 868 .ifnum = QUIRK_ANY_INTERFACE, 869 .type = QUIRK_COMPOSITE, 870 .data = (const struct snd_usb_audio_quirk[]) { 871 { 872 .ifnum = 1, 873 .type = QUIRK_AUDIO_EDIROL_UAXX 874 }, 875 { 876 .ifnum = 2, 877 .type = QUIRK_AUDIO_EDIROL_UAXX 878 }, 879 { 880 .ifnum = 3, 881 .type = QUIRK_AUDIO_EDIROL_UAXX 882 }, 883 { 884 .ifnum = -1 885 } 886 } 887 } 888 }, 889 { 890 /* has ID 0x002e when not in "Advanced Driver" mode */ 891 USB_DEVICE(0x0582, 0x002d), 892 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 893 .vendor_name = "Roland", 894 .product_name = "XV-2020", 895 .ifnum = 0, 896 .type = QUIRK_MIDI_FIXED_ENDPOINT, 897 .data = & (const struct snd_usb_midi_endpoint_info) { 898 .out_cables = 0x0001, 899 .in_cables = 0x0001 900 } 901 } 902 }, 903 { 904 /* has ID 0x0030 when not in "Advanced Driver" mode */ 905 USB_DEVICE(0x0582, 0x002f), 906 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 907 .vendor_name = "Roland", 908 .product_name = "VariOS", 909 .ifnum = 0, 910 .type = QUIRK_MIDI_FIXED_ENDPOINT, 911 .data = & (const struct snd_usb_midi_endpoint_info) { 912 .out_cables = 0x0007, 913 .in_cables = 0x0007 914 } 915 } 916 }, 917 { 918 /* has ID 0x0034 when not in "Advanced Driver" mode */ 919 USB_DEVICE(0x0582, 0x0033), 920 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 921 .vendor_name = "EDIROL", 922 .product_name = "PCR", 923 .ifnum = 0, 924 .type = QUIRK_MIDI_FIXED_ENDPOINT, 925 .data = & (const struct snd_usb_midi_endpoint_info) { 926 .out_cables = 0x0003, 927 .in_cables = 0x0007 928 } 929 } 930 }, 931 /* TODO: add Roland M-1000 support */ 932 { 933 /* 934 * Has ID 0x0038 when not in "Advanced Driver" mode; 935 * later revisions use IDs 0x0054 and 0x00a2. 936 */ 937 USB_DEVICE(0x0582, 0x0037), 938 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 939 .vendor_name = "Roland", 940 .product_name = "Digital Piano", 941 .ifnum = 0, 942 .type = QUIRK_MIDI_FIXED_ENDPOINT, 943 .data = & (const struct snd_usb_midi_endpoint_info) { 944 .out_cables = 0x0001, 945 .in_cables = 0x0001 946 } 947 } 948 }, 949 { 950 /* 951 * This quirk is for the "Advanced Driver" mode. If off, the GS-10 952 * has ID 0x003c and is standard compliant, but has only 16-bit PCM 953 * and no MIDI. 954 */ 955 USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b), 956 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 957 .vendor_name = "BOSS", 958 .product_name = "GS-10", 959 .ifnum = QUIRK_ANY_INTERFACE, 960 .type = QUIRK_COMPOSITE, 961 .data = & (const struct snd_usb_audio_quirk[]) { 962 { 963 .ifnum = 1, 964 .type = QUIRK_AUDIO_STANDARD_INTERFACE 965 }, 966 { 967 .ifnum = 2, 968 .type = QUIRK_AUDIO_STANDARD_INTERFACE 969 }, 970 { 971 .ifnum = 3, 972 .type = QUIRK_MIDI_STANDARD_INTERFACE 973 }, 974 { 975 .ifnum = -1 976 } 977 } 978 } 979 }, 980 { 981 /* has ID 0x0041 when not in "Advanced Driver" mode */ 982 USB_DEVICE(0x0582, 0x0040), 983 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 984 .vendor_name = "Roland", 985 .product_name = "GI-20", 986 .ifnum = 0, 987 .type = QUIRK_MIDI_FIXED_ENDPOINT, 988 .data = & (const struct snd_usb_midi_endpoint_info) { 989 .out_cables = 0x0001, 990 .in_cables = 0x0001 991 } 992 } 993 }, 994 { 995 /* has ID 0x0043 when not in "Advanced Driver" mode */ 996 USB_DEVICE(0x0582, 0x0042), 997 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 998 .vendor_name = "Roland", 999 .product_name = "RS-70", 1000 .ifnum = 0, 1001 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1002 .data = & (const struct snd_usb_midi_endpoint_info) { 1003 .out_cables = 0x0001, 1004 .in_cables = 0x0001 1005 } 1006 } 1007 }, 1008 { 1009 USB_DEVICE(0x0582, 0x0044), 1010 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1011 .vendor_name = "Roland", 1012 .product_name = "UA-1000", 1013 .ifnum = QUIRK_ANY_INTERFACE, 1014 .type = QUIRK_COMPOSITE, 1015 .data = (const struct snd_usb_audio_quirk[]) { 1016 { 1017 .ifnum = 1, 1018 .type = QUIRK_AUDIO_EDIROL_UA1000 1019 }, 1020 { 1021 .ifnum = 2, 1022 .type = QUIRK_AUDIO_EDIROL_UA1000 1023 }, 1024 { 1025 .ifnum = 3, 1026 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1027 .data = & (const struct snd_usb_midi_endpoint_info) { 1028 .out_cables = 0x0003, 1029 .in_cables = 0x0003 1030 } 1031 }, 1032 { 1033 .ifnum = -1 1034 } 1035 } 1036 } 1037 }, 1038 { 1039 /* has ID 0x0049 when not in "Advanced Driver" mode */ 1040 USB_DEVICE(0x0582, 0x0047), 1041 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1042 /* .vendor_name = "EDIROL", */ 1043 /* .product_name = "UR-80", */ 1044 .ifnum = QUIRK_ANY_INTERFACE, 1045 .type = QUIRK_COMPOSITE, 1046 .data = (const struct snd_usb_audio_quirk[]) { 1047 /* in the 96 kHz modes, only interface 1 is there */ 1048 { 1049 .ifnum = 1, 1050 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1051 }, 1052 { 1053 .ifnum = 2, 1054 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1055 }, 1056 { 1057 .ifnum = -1 1058 } 1059 } 1060 } 1061 }, 1062 { 1063 /* has ID 0x004a when not in "Advanced Driver" mode */ 1064 USB_DEVICE(0x0582, 0x0048), 1065 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1066 /* .vendor_name = "EDIROL", */ 1067 /* .product_name = "UR-80", */ 1068 .ifnum = 0, 1069 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1070 .data = & (const struct snd_usb_midi_endpoint_info) { 1071 .out_cables = 0x0003, 1072 .in_cables = 0x0007 1073 } 1074 } 1075 }, 1076 /* TODO: add Edirol M-100FX support */ 1077 { 1078 /* has ID 0x004e when not in "Advanced Driver" mode */ 1079 USB_DEVICE(0x0582, 0x004c), 1080 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1081 .vendor_name = "EDIROL", 1082 .product_name = "PCR-A", 1083 .ifnum = QUIRK_ANY_INTERFACE, 1084 .type = QUIRK_COMPOSITE, 1085 .data = (const struct snd_usb_audio_quirk[]) { 1086 { 1087 .ifnum = 1, 1088 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1089 }, 1090 { 1091 .ifnum = 2, 1092 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1093 }, 1094 { 1095 .ifnum = -1 1096 } 1097 } 1098 } 1099 }, 1100 { 1101 /* has ID 0x004f when not in "Advanced Driver" mode */ 1102 USB_DEVICE(0x0582, 0x004d), 1103 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1104 .vendor_name = "EDIROL", 1105 .product_name = "PCR-A", 1106 .ifnum = 0, 1107 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1108 .data = & (const struct snd_usb_midi_endpoint_info) { 1109 .out_cables = 0x0003, 1110 .in_cables = 0x0007 1111 } 1112 } 1113 }, 1114 { 1115 /* 1116 * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX 1117 * is standard compliant, but has only 16-bit PCM. 1118 */ 1119 USB_DEVICE(0x0582, 0x0050), 1120 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1121 .vendor_name = "EDIROL", 1122 .product_name = "UA-3FX", 1123 .ifnum = QUIRK_ANY_INTERFACE, 1124 .type = QUIRK_COMPOSITE, 1125 .data = (const struct snd_usb_audio_quirk[]) { 1126 { 1127 .ifnum = 1, 1128 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1129 }, 1130 { 1131 .ifnum = 2, 1132 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1133 }, 1134 { 1135 .ifnum = -1 1136 } 1137 } 1138 } 1139 }, 1140 { 1141 USB_DEVICE(0x0582, 0x0052), 1142 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1143 .vendor_name = "EDIROL", 1144 .product_name = "UM-1SX", 1145 .ifnum = 0, 1146 .type = QUIRK_MIDI_STANDARD_INTERFACE 1147 } 1148 }, 1149 { 1150 USB_DEVICE(0x0582, 0x0060), 1151 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1152 .vendor_name = "Roland", 1153 .product_name = "EXR Series", 1154 .ifnum = 0, 1155 .type = QUIRK_MIDI_STANDARD_INTERFACE 1156 } 1157 }, 1158 { 1159 /* has ID 0x0067 when not in "Advanced Driver" mode */ 1160 USB_DEVICE(0x0582, 0x0065), 1161 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1162 .vendor_name = "EDIROL", 1163 .product_name = "PCR-1", 1164 .ifnum = 0, 1165 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1166 .data = & (const struct snd_usb_midi_endpoint_info) { 1167 .out_cables = 0x0001, 1168 .in_cables = 0x0003 1169 } 1170 } 1171 }, 1172 { 1173 /* has ID 0x006b when not in "Advanced Driver" mode */ 1174 USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a), 1175 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1176 .vendor_name = "Roland", 1177 .product_name = "SP-606", 1178 .ifnum = 3, 1179 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1180 .data = & (const struct snd_usb_midi_endpoint_info) { 1181 .out_cables = 0x0001, 1182 .in_cables = 0x0001 1183 } 1184 } 1185 }, 1186 { 1187 /* has ID 0x006e when not in "Advanced Driver" mode */ 1188 USB_DEVICE(0x0582, 0x006d), 1189 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1190 .vendor_name = "Roland", 1191 .product_name = "FANTOM-X", 1192 .ifnum = 0, 1193 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1194 .data = & (const struct snd_usb_midi_endpoint_info) { 1195 .out_cables = 0x0001, 1196 .in_cables = 0x0001 1197 } 1198 } 1199 }, 1200 { /* 1201 * This quirk is for the "Advanced" modes of the Edirol UA-25. 1202 * If the switch is not in an advanced setting, the UA-25 has 1203 * ID 0x0582/0x0073 and is standard compliant (no quirks), but 1204 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1205 */ 1206 USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074), 1207 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1208 .vendor_name = "EDIROL", 1209 .product_name = "UA-25", 1210 .ifnum = QUIRK_ANY_INTERFACE, 1211 .type = QUIRK_COMPOSITE, 1212 .data = (const struct snd_usb_audio_quirk[]) { 1213 { 1214 .ifnum = 0, 1215 .type = QUIRK_AUDIO_EDIROL_UAXX 1216 }, 1217 { 1218 .ifnum = 1, 1219 .type = QUIRK_AUDIO_EDIROL_UAXX 1220 }, 1221 { 1222 .ifnum = 2, 1223 .type = QUIRK_AUDIO_EDIROL_UAXX 1224 }, 1225 { 1226 .ifnum = -1 1227 } 1228 } 1229 } 1230 }, 1231 { 1232 /* has ID 0x0076 when not in "Advanced Driver" mode */ 1233 USB_DEVICE(0x0582, 0x0075), 1234 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1235 .vendor_name = "BOSS", 1236 .product_name = "DR-880", 1237 .ifnum = 0, 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 0x007b when not in "Advanced Driver" mode */ 1247 USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a), 1248 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1249 .vendor_name = "Roland", 1250 /* "RD" or "RD-700SX"? */ 1251 .ifnum = 0, 1252 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1253 .data = & (const struct snd_usb_midi_endpoint_info) { 1254 .out_cables = 0x0003, 1255 .in_cables = 0x0003 1256 } 1257 } 1258 }, 1259 /* Roland UA-101 in High-Speed Mode only */ 1260 { 1261 USB_DEVICE(0x0582, 0x007d), 1262 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1263 .vendor_name = "Roland", 1264 .product_name = "UA-101", 1265 .ifnum = QUIRK_ANY_INTERFACE, 1266 .type = QUIRK_COMPOSITE, 1267 .data = (const struct snd_usb_audio_quirk[]) { 1268 { 1269 .ifnum = 0, 1270 .type = QUIRK_AUDIO_EDIROL_UA101 1271 }, 1272 { 1273 .ifnum = 1, 1274 .type = QUIRK_AUDIO_EDIROL_UA101 1275 }, 1276 { 1277 .ifnum = 2, 1278 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1279 .data = & (const struct snd_usb_midi_endpoint_info) { 1280 .out_cables = 0x0001, 1281 .in_cables = 0x0001 1282 } 1283 }, 1284 { 1285 .ifnum = -1 1286 } 1287 } 1288 } 1289 }, 1290 { 1291 /* has ID 0x0081 when not in "Advanced Driver" mode */ 1292 USB_DEVICE(0x0582, 0x0080), 1293 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1294 .vendor_name = "Roland", 1295 .product_name = "G-70", 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 /* TODO: add Roland V-SYNTH XT support */ 1305 /* TODO: add BOSS GT-PRO support */ 1306 { 1307 /* has ID 0x008c when not in "Advanced Driver" mode */ 1308 USB_DEVICE(0x0582, 0x008b), 1309 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1310 .vendor_name = "EDIROL", 1311 .product_name = "PC-50", 1312 .ifnum = 0, 1313 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1314 .data = & (const struct snd_usb_midi_endpoint_info) { 1315 .out_cables = 0x0001, 1316 .in_cables = 0x0001 1317 } 1318 } 1319 }, 1320 /* TODO: add Edirol PC-80 support */ 1321 { 1322 USB_DEVICE(0x0582, 0x0096), 1323 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1324 .vendor_name = "EDIROL", 1325 .product_name = "UA-1EX", 1326 .ifnum = QUIRK_ANY_INTERFACE, 1327 .type = QUIRK_COMPOSITE, 1328 .data = (const struct snd_usb_audio_quirk[]) { 1329 { 1330 .ifnum = 0, 1331 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1332 }, 1333 { 1334 .ifnum = 1, 1335 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1336 }, 1337 { 1338 .ifnum = -1 1339 } 1340 } 1341 } 1342 }, 1343 { 1344 USB_DEVICE(0x0582, 0x009a), 1345 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1346 .vendor_name = "EDIROL", 1347 .product_name = "UM-3EX", 1348 .ifnum = 0, 1349 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1350 .data = & (const struct snd_usb_midi_endpoint_info) { 1351 .out_cables = 0x000f, 1352 .in_cables = 0x000f 1353 } 1354 } 1355 }, 1356 { 1357 /* 1358 * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX 1359 * is standard compliant, but has only 16-bit PCM and no MIDI. 1360 */ 1361 USB_DEVICE(0x0582, 0x00a3), 1362 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1363 .vendor_name = "EDIROL", 1364 .product_name = "UA-4FX", 1365 .ifnum = QUIRK_ANY_INTERFACE, 1366 .type = QUIRK_COMPOSITE, 1367 .data = (const struct snd_usb_audio_quirk[]) { 1368 { 1369 .ifnum = 0, 1370 .type = QUIRK_AUDIO_EDIROL_UAXX 1371 }, 1372 { 1373 .ifnum = 1, 1374 .type = QUIRK_AUDIO_EDIROL_UAXX 1375 }, 1376 { 1377 .ifnum = 2, 1378 .type = QUIRK_AUDIO_EDIROL_UAXX 1379 }, 1380 { 1381 .ifnum = -1 1382 } 1383 } 1384 } 1385 }, 1386 /* TODO: add Edirol MD-P1 support */ 1387 { 1388 USB_DEVICE(0x582, 0x00a6), 1389 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1390 .vendor_name = "Roland", 1391 .product_name = "Juno-G", 1392 .ifnum = 0, 1393 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1394 .data = & (const struct snd_usb_midi_endpoint_info) { 1395 .out_cables = 0x0001, 1396 .in_cables = 0x0001 1397 } 1398 } 1399 }, 1400 { 1401 /* Roland SH-201 */ 1402 USB_DEVICE(0x0582, 0x00ad), 1403 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1404 .vendor_name = "Roland", 1405 .product_name = "SH-201", 1406 .ifnum = QUIRK_ANY_INTERFACE, 1407 .type = QUIRK_COMPOSITE, 1408 .data = (const struct snd_usb_audio_quirk[]) { 1409 { 1410 .ifnum = 0, 1411 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1412 }, 1413 { 1414 .ifnum = 1, 1415 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1416 }, 1417 { 1418 .ifnum = 2, 1419 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1420 .data = & (const struct snd_usb_midi_endpoint_info) { 1421 .out_cables = 0x0001, 1422 .in_cables = 0x0001 1423 } 1424 }, 1425 { 1426 .ifnum = -1 1427 } 1428 } 1429 } 1430 }, 1431 { 1432 /* Roland SonicCell */ 1433 USB_DEVICE(0x0582, 0x00c2), 1434 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1435 .vendor_name = "Roland", 1436 .product_name = "SonicCell", 1437 .ifnum = QUIRK_ANY_INTERFACE, 1438 .type = QUIRK_COMPOSITE, 1439 .data = (const struct snd_usb_audio_quirk[]) { 1440 { 1441 .ifnum = 0, 1442 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1443 }, 1444 { 1445 .ifnum = 1, 1446 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1447 }, 1448 { 1449 .ifnum = 2, 1450 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1451 .data = & (const struct snd_usb_midi_endpoint_info) { 1452 .out_cables = 0x0001, 1453 .in_cables = 0x0001 1454 } 1455 }, 1456 { 1457 .ifnum = -1 1458 } 1459 } 1460 } 1461 }, 1462 { 1463 /* BOSS GT-10 */ 1464 USB_DEVICE(0x0582, 0x00da), 1465 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1466 .ifnum = QUIRK_ANY_INTERFACE, 1467 .type = QUIRK_COMPOSITE, 1468 .data = (const struct snd_usb_audio_quirk[]) { 1469 { 1470 .ifnum = 0, 1471 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1472 }, 1473 { 1474 .ifnum = 1, 1475 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1476 }, 1477 { 1478 .ifnum = 2, 1479 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1480 .data = & (const struct snd_usb_midi_endpoint_info) { 1481 .out_cables = 0x0001, 1482 .in_cables = 0x0001 1483 } 1484 }, 1485 { 1486 .ifnum = -1 1487 } 1488 } 1489 } 1490 }, 1491 { 1492 /* Advanced modes of the Edirol UA-25EX. 1493 * For the standard mode, UA-25EX has ID 0582:00e7, which 1494 * offers only 16-bit PCM at 44.1 kHz and no MIDI. 1495 */ 1496 USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6), 1497 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1498 .vendor_name = "EDIROL", 1499 .product_name = "UA-25EX", 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_EDIROL_UAXX 1506 }, 1507 { 1508 .ifnum = 1, 1509 .type = QUIRK_AUDIO_EDIROL_UAXX 1510 }, 1511 { 1512 .ifnum = 2, 1513 .type = QUIRK_AUDIO_EDIROL_UAXX 1514 }, 1515 { 1516 .ifnum = -1 1517 } 1518 } 1519 } 1520 }, 1521 1522 /* Guillemot devices */ 1523 { 1524 /* 1525 * This is for the "Windows Edition" where the external MIDI ports are 1526 * the only MIDI ports; the control data is reported through HID 1527 * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard 1528 * compliant USB MIDI ports for external MIDI and controls. 1529 */ 1530 USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000), 1531 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1532 .vendor_name = "Hercules", 1533 .product_name = "DJ Console (WE)", 1534 .ifnum = 4, 1535 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1536 .data = & (const struct snd_usb_midi_endpoint_info) { 1537 .out_cables = 0x0001, 1538 .in_cables = 0x0001 1539 } 1540 } 1541 }, 1542 1543 /* Midiman/M-Audio devices */ 1544 { 1545 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002), 1546 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1547 .vendor_name = "M-Audio", 1548 .product_name = "MidiSport 2x2", 1549 .ifnum = QUIRK_ANY_INTERFACE, 1550 .type = QUIRK_MIDI_MIDIMAN, 1551 .data = & (const struct snd_usb_midi_endpoint_info) { 1552 .out_cables = 0x0003, 1553 .in_cables = 0x0003 1554 } 1555 } 1556 }, 1557 { 1558 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011), 1559 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1560 .vendor_name = "M-Audio", 1561 .product_name = "MidiSport 1x1", 1562 .ifnum = QUIRK_ANY_INTERFACE, 1563 .type = QUIRK_MIDI_MIDIMAN, 1564 .data = & (const struct snd_usb_midi_endpoint_info) { 1565 .out_cables = 0x0001, 1566 .in_cables = 0x0001 1567 } 1568 } 1569 }, 1570 { 1571 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015), 1572 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1573 .vendor_name = "M-Audio", 1574 .product_name = "Keystation", 1575 .ifnum = QUIRK_ANY_INTERFACE, 1576 .type = QUIRK_MIDI_MIDIMAN, 1577 .data = & (const struct snd_usb_midi_endpoint_info) { 1578 .out_cables = 0x0001, 1579 .in_cables = 0x0001 1580 } 1581 } 1582 }, 1583 { 1584 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021), 1585 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1586 .vendor_name = "M-Audio", 1587 .product_name = "MidiSport 4x4", 1588 .ifnum = QUIRK_ANY_INTERFACE, 1589 .type = QUIRK_MIDI_MIDIMAN, 1590 .data = & (const struct snd_usb_midi_endpoint_info) { 1591 .out_cables = 0x000f, 1592 .in_cables = 0x000f 1593 } 1594 } 1595 }, 1596 { 1597 /* 1598 * For hardware revision 1.05; in the later revisions (1.10 and 1599 * 1.21), 0x1031 is the ID for the device without firmware. 1600 * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de> 1601 */ 1602 USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109), 1603 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1604 .vendor_name = "M-Audio", 1605 .product_name = "MidiSport 8x8", 1606 .ifnum = QUIRK_ANY_INTERFACE, 1607 .type = QUIRK_MIDI_MIDIMAN, 1608 .data = & (const struct snd_usb_midi_endpoint_info) { 1609 .out_cables = 0x01ff, 1610 .in_cables = 0x01ff 1611 } 1612 } 1613 }, 1614 { 1615 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033), 1616 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1617 .vendor_name = "M-Audio", 1618 .product_name = "MidiSport 8x8", 1619 .ifnum = QUIRK_ANY_INTERFACE, 1620 .type = QUIRK_MIDI_MIDIMAN, 1621 .data = & (const struct snd_usb_midi_endpoint_info) { 1622 .out_cables = 0x01ff, 1623 .in_cables = 0x01ff 1624 } 1625 } 1626 }, 1627 { 1628 USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041), 1629 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1630 .vendor_name = "M-Audio", 1631 .product_name = "MidiSport 2x4", 1632 .ifnum = QUIRK_ANY_INTERFACE, 1633 .type = QUIRK_MIDI_MIDIMAN, 1634 .data = & (const struct snd_usb_midi_endpoint_info) { 1635 .out_cables = 0x000f, 1636 .in_cables = 0x0003 1637 } 1638 } 1639 }, 1640 { 1641 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001), 1642 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1643 .vendor_name = "M-Audio", 1644 .product_name = "Quattro", 1645 .ifnum = QUIRK_ANY_INTERFACE, 1646 .type = QUIRK_COMPOSITE, 1647 .data = & (const struct snd_usb_audio_quirk[]) { 1648 /* 1649 * Interfaces 0-2 are "Windows-compatible", 16-bit only, 1650 * and share endpoints with the other interfaces. 1651 * Ignore them. The other interfaces can do 24 bits, 1652 * but captured samples are big-endian (see usbaudio.c). 1653 */ 1654 { 1655 .ifnum = 0, 1656 .type = QUIRK_IGNORE_INTERFACE 1657 }, 1658 { 1659 .ifnum = 1, 1660 .type = QUIRK_IGNORE_INTERFACE 1661 }, 1662 { 1663 .ifnum = 2, 1664 .type = QUIRK_IGNORE_INTERFACE 1665 }, 1666 { 1667 .ifnum = 3, 1668 .type = QUIRK_IGNORE_INTERFACE 1669 }, 1670 { 1671 .ifnum = 4, 1672 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1673 }, 1674 { 1675 .ifnum = 5, 1676 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1677 }, 1678 { 1679 .ifnum = 6, 1680 .type = QUIRK_IGNORE_INTERFACE 1681 }, 1682 { 1683 .ifnum = 7, 1684 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1685 }, 1686 { 1687 .ifnum = 8, 1688 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1689 }, 1690 { 1691 .ifnum = 9, 1692 .type = QUIRK_MIDI_MIDIMAN, 1693 .data = & (const struct snd_usb_midi_endpoint_info) { 1694 .out_cables = 0x0001, 1695 .in_cables = 0x0001 1696 } 1697 }, 1698 { 1699 .ifnum = -1 1700 } 1701 } 1702 } 1703 }, 1704 { 1705 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003), 1706 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1707 .vendor_name = "M-Audio", 1708 .product_name = "AudioPhile", 1709 .ifnum = 6, 1710 .type = QUIRK_MIDI_MIDIMAN, 1711 .data = & (const struct snd_usb_midi_endpoint_info) { 1712 .out_cables = 0x0001, 1713 .in_cables = 0x0001 1714 } 1715 } 1716 }, 1717 { 1718 USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008), 1719 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1720 .vendor_name = "M-Audio", 1721 .product_name = "Ozone", 1722 .ifnum = 3, 1723 .type = QUIRK_MIDI_MIDIMAN, 1724 .data = & (const struct snd_usb_midi_endpoint_info) { 1725 .out_cables = 0x0001, 1726 .in_cables = 0x0001 1727 } 1728 } 1729 }, 1730 { 1731 USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d), 1732 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1733 .vendor_name = "M-Audio", 1734 .product_name = "OmniStudio", 1735 .ifnum = QUIRK_ANY_INTERFACE, 1736 .type = QUIRK_COMPOSITE, 1737 .data = & (const struct snd_usb_audio_quirk[]) { 1738 { 1739 .ifnum = 0, 1740 .type = QUIRK_IGNORE_INTERFACE 1741 }, 1742 { 1743 .ifnum = 1, 1744 .type = QUIRK_IGNORE_INTERFACE 1745 }, 1746 { 1747 .ifnum = 2, 1748 .type = QUIRK_IGNORE_INTERFACE 1749 }, 1750 { 1751 .ifnum = 3, 1752 .type = QUIRK_IGNORE_INTERFACE 1753 }, 1754 { 1755 .ifnum = 4, 1756 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1757 }, 1758 { 1759 .ifnum = 5, 1760 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1761 }, 1762 { 1763 .ifnum = 6, 1764 .type = QUIRK_IGNORE_INTERFACE 1765 }, 1766 { 1767 .ifnum = 7, 1768 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1769 }, 1770 { 1771 .ifnum = 8, 1772 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1773 }, 1774 { 1775 .ifnum = 9, 1776 .type = QUIRK_MIDI_MIDIMAN, 1777 .data = & (const struct snd_usb_midi_endpoint_info) { 1778 .out_cables = 0x0001, 1779 .in_cables = 0x0001 1780 } 1781 }, 1782 { 1783 .ifnum = -1 1784 } 1785 } 1786 } 1787 }, 1788 { 1789 USB_DEVICE(0x0763, 0x2019), 1790 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1791 /* .vendor_name = "M-Audio", */ 1792 /* .product_name = "Ozone Academic", */ 1793 .ifnum = QUIRK_ANY_INTERFACE, 1794 .type = QUIRK_COMPOSITE, 1795 .data = & (const struct snd_usb_audio_quirk[]) { 1796 { 1797 .ifnum = 0, 1798 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1799 }, 1800 { 1801 .ifnum = 1, 1802 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1803 }, 1804 { 1805 .ifnum = 2, 1806 .type = QUIRK_AUDIO_STANDARD_INTERFACE 1807 }, 1808 { 1809 .ifnum = 3, 1810 .type = QUIRK_MIDI_MIDIMAN, 1811 .data = & (const struct snd_usb_midi_endpoint_info) { 1812 .out_cables = 0x0001, 1813 .in_cables = 0x0001 1814 } 1815 }, 1816 { 1817 .ifnum = -1 1818 } 1819 } 1820 } 1821 }, 1822 1823 /* Casio devices */ 1824 { 1825 USB_DEVICE(0x07cf, 0x6801), 1826 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1827 .vendor_name = "Casio", 1828 .product_name = "PL-40R", 1829 .ifnum = 0, 1830 .type = QUIRK_MIDI_YAMAHA 1831 } 1832 }, 1833 { 1834 /* this ID is used by several devices without a product ID */ 1835 USB_DEVICE(0x07cf, 0x6802), 1836 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1837 .vendor_name = "Casio", 1838 .product_name = "Keyboard", 1839 .ifnum = 0, 1840 .type = QUIRK_MIDI_YAMAHA 1841 } 1842 }, 1843 1844 /* Mark of the Unicorn devices */ 1845 { 1846 /* thanks to Robert A. Lerche <ral 'at' msbit.com> */ 1847 .match_flags = USB_DEVICE_ID_MATCH_VENDOR | 1848 USB_DEVICE_ID_MATCH_PRODUCT | 1849 USB_DEVICE_ID_MATCH_DEV_SUBCLASS, 1850 .idVendor = 0x07fd, 1851 .idProduct = 0x0001, 1852 .bDeviceSubClass = 2, 1853 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1854 .vendor_name = "MOTU", 1855 .product_name = "Fastlane", 1856 .ifnum = QUIRK_ANY_INTERFACE, 1857 .type = QUIRK_COMPOSITE, 1858 .data = & (const struct snd_usb_audio_quirk[]) { 1859 { 1860 .ifnum = 0, 1861 .type = QUIRK_MIDI_RAW 1862 }, 1863 { 1864 .ifnum = 1, 1865 .type = QUIRK_IGNORE_INTERFACE 1866 }, 1867 { 1868 .ifnum = -1 1869 } 1870 } 1871 } 1872 }, 1873 1874 /* Emagic devices */ 1875 { 1876 USB_DEVICE(0x086a, 0x0001), 1877 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1878 .vendor_name = "Emagic", 1879 /* .product_name = "Unitor8", */ 1880 .ifnum = 2, 1881 .type = QUIRK_MIDI_EMAGIC, 1882 .data = & (const struct snd_usb_midi_endpoint_info) { 1883 .out_cables = 0x80ff, 1884 .in_cables = 0x80ff 1885 } 1886 } 1887 }, 1888 { 1889 USB_DEVICE(0x086a, 0x0002), 1890 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1891 .vendor_name = "Emagic", 1892 /* .product_name = "AMT8", */ 1893 .ifnum = 2, 1894 .type = QUIRK_MIDI_EMAGIC, 1895 .data = & (const struct snd_usb_midi_endpoint_info) { 1896 .out_cables = 0x80ff, 1897 .in_cables = 0x80ff 1898 } 1899 } 1900 }, 1901 { 1902 USB_DEVICE(0x086a, 0x0003), 1903 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1904 .vendor_name = "Emagic", 1905 /* .product_name = "MT4", */ 1906 .ifnum = 2, 1907 .type = QUIRK_MIDI_EMAGIC, 1908 .data = & (const struct snd_usb_midi_endpoint_info) { 1909 .out_cables = 0x800f, 1910 .in_cables = 0x8003 1911 } 1912 } 1913 }, 1914 1915 /* TerraTec devices */ 1916 { 1917 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012), 1918 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1919 .vendor_name = "TerraTec", 1920 .product_name = "PHASE 26", 1921 .ifnum = 3, 1922 .type = QUIRK_MIDI_STANDARD_INTERFACE 1923 } 1924 }, 1925 { 1926 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013), 1927 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1928 .vendor_name = "TerraTec", 1929 .product_name = "PHASE 26", 1930 .ifnum = 3, 1931 .type = QUIRK_MIDI_STANDARD_INTERFACE 1932 } 1933 }, 1934 { 1935 USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014), 1936 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1937 .vendor_name = "TerraTec", 1938 .product_name = "PHASE 26", 1939 .ifnum = 3, 1940 .type = QUIRK_MIDI_STANDARD_INTERFACE 1941 } 1942 }, 1943 { 1944 USB_DEVICE(0x0ccd, 0x0035), 1945 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1946 .vendor_name = "Miditech", 1947 .product_name = "Play'n Roll", 1948 .ifnum = 0, 1949 .type = QUIRK_MIDI_CME 1950 } 1951 }, 1952 1953 /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */ 1954 { 1955 USB_DEVICE(0x103d, 0x0100), 1956 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1957 .vendor_name = "Stanton", 1958 .product_name = "ScratchAmp", 1959 .ifnum = QUIRK_NO_INTERFACE 1960 } 1961 }, 1962 { 1963 USB_DEVICE(0x103d, 0x0101), 1964 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1965 .vendor_name = "Stanton", 1966 .product_name = "ScratchAmp", 1967 .ifnum = QUIRK_NO_INTERFACE 1968 } 1969 }, 1970 1971 /* Novation EMS devices */ 1972 { 1973 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001), 1974 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1975 .vendor_name = "Novation", 1976 .product_name = "ReMOTE Audio/XStation", 1977 .ifnum = 4, 1978 .type = QUIRK_MIDI_NOVATION 1979 } 1980 }, 1981 { 1982 USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002), 1983 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1984 .vendor_name = "Novation", 1985 .product_name = "Speedio", 1986 .ifnum = 3, 1987 .type = QUIRK_MIDI_NOVATION 1988 } 1989 }, 1990 { 1991 USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), 1992 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 1993 .vendor_name = "Novation", 1994 .product_name = "ReMOTE25", 1995 .ifnum = 0, 1996 .type = QUIRK_MIDI_NOVATION 1997 } 1998 }, 1999 2000 /* */ 2001 { 2002 /* aka. Serato Scratch Live DJ Box */ 2003 USB_DEVICE(0x13e5, 0x0001), 2004 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2005 .vendor_name = "Rane", 2006 .product_name = "SL-1", 2007 .ifnum = QUIRK_NO_INTERFACE 2008 } 2009 }, 2010 2011 /* Miditech devices */ 2012 { 2013 USB_DEVICE(0x4752, 0x0011), 2014 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2015 .vendor_name = "Miditech", 2016 .product_name = "Midistart-2", 2017 .ifnum = 0, 2018 .type = QUIRK_MIDI_CME 2019 } 2020 }, 2021 2022 /* Central Music devices */ 2023 { 2024 /* this ID used by both Miditech MidiStudio-2 and CME UF-x */ 2025 USB_DEVICE(0x7104, 0x2202), 2026 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2027 .ifnum = 0, 2028 .type = QUIRK_MIDI_CME 2029 } 2030 }, 2031 2032 { 2033 /* 2034 * Some USB MIDI devices don't have an audio control interface, 2035 * so we have to grab MIDI streaming interfaces here. 2036 */ 2037 .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS | 2038 USB_DEVICE_ID_MATCH_INT_SUBCLASS, 2039 .bInterfaceClass = USB_CLASS_AUDIO, 2040 .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING, 2041 .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { 2042 .ifnum = QUIRK_ANY_INTERFACE, 2043 .type = QUIRK_MIDI_STANDARD_INTERFACE 2044 } 2045 }, 2046 2047 #undef USB_DEVICE_VENDOR_SPEC 2048