SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/usb/usbquirks.h

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