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