git.oblomov.eu Git - linux-2.6/blob - sound/usb/usbquirks.h

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