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