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

   1 /*
   2  * ALSA USB Audio Driver
   3  *
   4  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   5  *                       Clemens Ladisch <clemens@ladisch.de>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 /*
  24  * The contents of this file are part of the driver's id_table.
  25  *
  26  * In a perfect world, this file would be empty.
  27  */
  28
  29 /*
  30  * Use this for devices where other interfaces are standard compliant,
  31  * to prevent the quirk being applied to those interfaces. (To work with
  32  * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  33  */
  34 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  35         .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  36                        USB_DEVICE_ID_MATCH_PRODUCT | \
  37                        USB_DEVICE_ID_MATCH_INT_CLASS, \
  38         .idVendor = vend, \
  39         .idProduct = prod, \
  40         .bInterfaceClass = USB_CLASS_VENDOR_SPEC
  41
  42 /*
  43  * Yamaha devices
  44  */
  45
  46 #define YAMAHA_DEVICE(id, name) { \
  47         USB_DEVICE(0x0499, id), \
  48         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \
  49                 .vendor_name = "Yamaha", \
  50                 .product_name = name, \
  51                 .ifnum = QUIRK_ANY_INTERFACE, \
  52                 .type = QUIRK_MIDI_YAMAHA \
  53         } \
  54 }
  55 #define YAMAHA_INTERFACE(id, intf, name) { \
  56         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
  57         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \
  58                 .vendor_name = "Yamaha", \
  59                 .product_name = name, \
  60                 .ifnum = intf, \
  61                 .type = QUIRK_MIDI_YAMAHA \
  62         } \
  63 }
  64 YAMAHA_DEVICE(0x1000, "UX256"),
  65 YAMAHA_DEVICE(0x1001, "MU1000"),
  66 YAMAHA_DEVICE(0x1002, "MU2000"),
  67 YAMAHA_DEVICE(0x1003, "MU500"),
  68 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
  69 YAMAHA_DEVICE(0x1005, "MOTIF6"),
  70 YAMAHA_DEVICE(0x1006, "MOTIF7"),
  71 YAMAHA_DEVICE(0x1007, "MOTIF8"),
  72 YAMAHA_DEVICE(0x1008, "UX96"),
  73 YAMAHA_DEVICE(0x1009, "UX16"),
  74 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
  75 YAMAHA_DEVICE(0x100c, "UC-MX"),
  76 YAMAHA_DEVICE(0x100d, "UC-KX"),
  77 YAMAHA_DEVICE(0x100e, "S08"),
  78 YAMAHA_DEVICE(0x100f, "CLP-150"),
  79 YAMAHA_DEVICE(0x1010, "CLP-170"),
  80 YAMAHA_DEVICE(0x1011, "P-250"),
  81 YAMAHA_DEVICE(0x1012, "TYROS"),
  82 YAMAHA_DEVICE(0x1013, "PF-500"),
  83 YAMAHA_DEVICE(0x1014, "S90"),
  84 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
  85 YAMAHA_DEVICE(0x1017, "CVP-204"),
  86 YAMAHA_DEVICE(0x1018, "CVP-206"),
  87 YAMAHA_DEVICE(0x1019, "CVP-208"),
  88 YAMAHA_DEVICE(0x101a, "CVP-210"),
  89 YAMAHA_DEVICE(0x101b, "PSR-1100"),
  90 YAMAHA_DEVICE(0x101c, "PSR-2100"),
  91 YAMAHA_DEVICE(0x101d, "CLP-175"),
  92 YAMAHA_DEVICE(0x101e, "PSR-K1"),
  93 YAMAHA_DEVICE(0x1020, "EZ-250i"),
  94 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
  95 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
  96 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
  97 YAMAHA_DEVICE(0x1024, "CVP-301"),
  98 YAMAHA_DEVICE(0x1025, "CVP-303"),
  99 YAMAHA_DEVICE(0x1026, "CVP-305"),
 100 YAMAHA_DEVICE(0x1027, "CVP-307"),
 101 YAMAHA_DEVICE(0x1028, "CVP-309"),
 102 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 103 YAMAHA_DEVICE(0x102a, "PSR-1500"),
 104 YAMAHA_DEVICE(0x102b, "PSR-3000"),
 105 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 106 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 107 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 108 YAMAHA_DEVICE(0x1032, "DGX-305"),
 109 YAMAHA_DEVICE(0x1033, "DGX-505"),
 110 YAMAHA_DEVICE(0x1034, NULL),
 111 YAMAHA_DEVICE(0x1035, NULL),
 112 YAMAHA_DEVICE(0x1036, NULL),
 113 YAMAHA_DEVICE(0x1037, NULL),
 114 YAMAHA_DEVICE(0x1038, NULL),
 115 YAMAHA_DEVICE(0x1039, NULL),
 116 YAMAHA_DEVICE(0x103a, NULL),
 117 YAMAHA_DEVICE(0x103b, NULL),
 118 YAMAHA_DEVICE(0x103c, NULL),
 119 YAMAHA_DEVICE(0x2000, "DGP-7"),
 120 YAMAHA_DEVICE(0x2001, "DGP-5"),
 121 YAMAHA_DEVICE(0x2002, NULL),
 122 YAMAHA_DEVICE(0x5000, "CS1D"),
 123 YAMAHA_DEVICE(0x5001, "DSP1D"),
 124 YAMAHA_DEVICE(0x5002, "DME32"),
 125 YAMAHA_DEVICE(0x5003, "DM2000"),
 126 YAMAHA_DEVICE(0x5004, "02R96"),
 127 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 128 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 129 YAMAHA_DEVICE(0x5007, "DM1000"),
 130 YAMAHA_DEVICE(0x5008, "01V96"),
 131 YAMAHA_DEVICE(0x5009, "SPX2000"),
 132 YAMAHA_DEVICE(0x500a, "PM5D"),
 133 YAMAHA_DEVICE(0x500b, "DME64N"),
 134 YAMAHA_DEVICE(0x500c, "DME24N"),
 135 YAMAHA_DEVICE(0x500d, NULL),
 136 YAMAHA_DEVICE(0x500e, NULL),
 137 YAMAHA_DEVICE(0x7000, "DTX"),
 138 YAMAHA_DEVICE(0x7010, "UB99"),
 139 #undef YAMAHA_DEVICE
 140 #undef YAMAHA_INTERFACE
 141
 142 /*
 143  * Roland/RolandED/Edirol/BOSS devices
 144  */
 145 {
 146         USB_DEVICE(0x0582, 0x0000),
 147         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 148                 .vendor_name = "Roland",
 149                 .product_name = "UA-100",
 150                 .ifnum = QUIRK_ANY_INTERFACE,
 151                 .type = QUIRK_COMPOSITE,
 152                 .data = (const snd_usb_audio_quirk_t[]) {
 153                         {
 154                                 .ifnum = 0,
 155                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 156                                 .data = & (const struct audioformat) {
 157                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 158                                         .channels = 4,
 159                                         .iface = 0,
 160                                         .altsetting = 1,
 161                                         .altset_idx = 1,
 162                                         .attributes = 0,
 163                                         .endpoint = 0x01,
 164                                         .ep_attr = 0x09,
 165                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 166                                         .rate_min = 44100,
 167                                         .rate_max = 44100,
 168                                 }
 169                         },
 170                         {
 171                                 .ifnum = 1,
 172                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 173                                 .data = & (const struct audioformat) {
 174                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 175                                         .channels = 2,
 176                                         .iface = 1,
 177                                         .altsetting = 1,
 178                                         .altset_idx = 1,
 179                                         .attributes = EP_CS_ATTR_FILL_MAX,
 180                                         .endpoint = 0x81,
 181                                         .ep_attr = 0x05,
 182                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 183                                         .rate_min = 44100,
 184                                         .rate_max = 44100,
 185                                 }
 186                         },
 187                         {
 188                                 .ifnum = 2,
 189                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 190                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 191                                         .out_cables = 0x0007,
 192                                         .in_cables  = 0x0007
 193                                 }
 194                         },
 195                         {
 196                                 .ifnum = -1
 197                         }
 198                 }
 199         }
 200 },
 201 {
 202         USB_DEVICE(0x0582, 0x0002),
 203         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 204                 .vendor_name = "EDIROL",
 205                 .product_name = "UM-4",
 206                 .ifnum = 2,
 207                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 208                 .data = & (const snd_usb_midi_endpoint_info_t) {
 209                         .out_cables = 0x000f,
 210                         .in_cables  = 0x000f
 211                 }
 212         }
 213 },
 214 {
 215         USB_DEVICE(0x0582, 0x0003),
 216         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 217                 .vendor_name = "Roland",
 218                 .product_name = "SC-8850",
 219                 .ifnum = 2,
 220                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 221                 .data = & (const snd_usb_midi_endpoint_info_t) {
 222                         .out_cables = 0x003f,
 223                         .in_cables  = 0x003f
 224                 }
 225         }
 226 },
 227 {
 228         USB_DEVICE(0x0582, 0x0004),
 229         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 230                 .vendor_name = "Roland",
 231                 .product_name = "U-8",
 232                 .ifnum = 2,
 233                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 234                 .data = & (const snd_usb_midi_endpoint_info_t) {
 235                         .out_cables = 0x0005,
 236                         .in_cables  = 0x0005
 237                 }
 238         }
 239 },
 240 {
 241         USB_DEVICE(0x0582, 0x0005),
 242         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 243                 .vendor_name = "EDIROL",
 244                 .product_name = "UM-2",
 245                 .ifnum = 2,
 246                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 247                 .data = & (const snd_usb_midi_endpoint_info_t) {
 248                         .out_cables = 0x0003,
 249                         .in_cables  = 0x0003
 250                 }
 251         }
 252 },
 253 {
 254         USB_DEVICE(0x0582, 0x0007),
 255         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 256                 .vendor_name = "Roland",
 257                 .product_name = "SC-8820",
 258                 .ifnum = 2,
 259                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 260                 .data = & (const snd_usb_midi_endpoint_info_t) {
 261                         .out_cables = 0x0013,
 262                         .in_cables  = 0x0013
 263                 }
 264         }
 265 },
 266 {
 267         USB_DEVICE(0x0582, 0x0008),
 268         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 269                 .vendor_name = "Roland",
 270                 .product_name = "PC-300",
 271                 .ifnum = 2,
 272                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 273                 .data = & (const snd_usb_midi_endpoint_info_t) {
 274                         .out_cables = 0x0001,
 275                         .in_cables  = 0x0001
 276                 }
 277         }
 278 },
 279 {
 280         USB_DEVICE(0x0582, 0x0009),
 281         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 282                 .vendor_name = "EDIROL",
 283                 .product_name = "UM-1",
 284                 .ifnum = 2,
 285                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 286                 .data = & (const snd_usb_midi_endpoint_info_t) {
 287                         .out_cables = 0x0001,
 288                         .in_cables  = 0x0001
 289                 }
 290         }
 291 },
 292 {
 293         USB_DEVICE(0x0582, 0x000b),
 294         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 295                 .vendor_name = "Roland",
 296                 .product_name = "SK-500",
 297                 .ifnum = 2,
 298                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 299                 .data = & (const snd_usb_midi_endpoint_info_t) {
 300                         .out_cables = 0x0013,
 301                         .in_cables  = 0x0013
 302                 }
 303         }
 304 },
 305 {
 306         /* thanks to Emiliano Grilli <emillo@libero.it>
 307          * for helping researching this data */
 308         USB_DEVICE(0x0582, 0x000c),
 309         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 310                 .vendor_name = "Roland",
 311                 .product_name = "SC-D70",
 312                 .ifnum = QUIRK_ANY_INTERFACE,
 313                 .type = QUIRK_COMPOSITE,
 314                 .data = (const snd_usb_audio_quirk_t[]) {
 315                         {
 316                                 .ifnum = 0,
 317                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 318                                 .data = & (const struct audioformat) {
 319                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 320                                         .channels = 2,
 321                                         .iface = 0,
 322                                         .altsetting = 1,
 323                                         .altset_idx = 1,
 324                                         .attributes = 0,
 325                                         .endpoint = 0x01,
 326                                         .ep_attr = 0x01,
 327                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 328                                         .rate_min = 44100,
 329                                         .rate_max = 44100,
 330                                 }
 331                         },
 332                         {
 333                                 .ifnum = 1,
 334                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 335                                 .data = & (const struct audioformat) {
 336                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 337                                         .channels = 2,
 338                                         .iface = 1,
 339                                         .altsetting = 1,
 340                                         .altset_idx = 1,
 341                                         .attributes = 0,
 342                                         .endpoint = 0x81,
 343                                         .ep_attr = 0x01,
 344                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 345                                         .rate_min = 44100,
 346                                         .rate_max = 44100,
 347                                 }
 348                         },
 349                         {
 350                                 .ifnum = 2,
 351                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 352                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 353                                         .out_cables = 0x0007,
 354                                         .in_cables  = 0x0007
 355                                 }
 356                         },
 357                         {
 358                                 .ifnum = -1
 359                         }
 360                 }
 361         }
 362 },
 363 {       /*
 364          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 365          * If the advanced mode switch at the back of the unit is off, the
 366          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 367          * but offers only 16-bit PCM.
 368          * In advanced mode, the UA-5 will output S24_3LE samples (two
 369          * channels) at the rate indicated on the front switch, including
 370          * the 96kHz sample rate.
 371          */
 372         USB_DEVICE(0x0582, 0x0010),
 373         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 374                 .vendor_name = "EDIROL",
 375                 .product_name = "UA-5",
 376                 .ifnum = QUIRK_ANY_INTERFACE,
 377                 .type = QUIRK_COMPOSITE,
 378                 .data = (const snd_usb_audio_quirk_t[]) {
 379                         {
 380                                 .ifnum = 1,
 381                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 382                         },
 383                         {
 384                                 .ifnum = 2,
 385                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 386                         },
 387                         {
 388                                 .ifnum = -1
 389                         }
 390                 }
 391         }
 392 },
 393 {
 394         USB_DEVICE(0x0582, 0x0012),
 395         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 396                 .vendor_name = "Roland",
 397                 .product_name = "XV-5050",
 398                 .ifnum = 0,
 399                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 400                 .data = & (const snd_usb_midi_endpoint_info_t) {
 401                         .out_cables = 0x0001,
 402                         .in_cables  = 0x0001
 403                 }
 404         }
 405 },
 406 {
 407         USB_DEVICE(0x0582, 0x0014),
 408         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 409                 .vendor_name = "EDIROL",
 410                 .product_name = "UM-880",
 411                 .ifnum = 0,
 412                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 413                 .data = & (const snd_usb_midi_endpoint_info_t) {
 414                         .out_cables = 0x01ff,
 415                         .in_cables  = 0x01ff
 416                 }
 417         }
 418 },
 419 {
 420         USB_DEVICE(0x0582, 0x0016),
 421         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 422                 .vendor_name = "EDIROL",
 423                 .product_name = "SD-90",
 424                 .ifnum = 2,
 425                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 426                 .data = & (const snd_usb_midi_endpoint_info_t) {
 427                         .out_cables = 0x000f,
 428                         .in_cables  = 0x000f
 429                 }
 430         }
 431 },
 432 {
 433         USB_DEVICE(0x0582, 0x001b),
 434         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 435                 .vendor_name = "Roland",
 436                 .product_name = "MMP-2",
 437                 .ifnum = 2,
 438                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 439                 .data = & (const snd_usb_midi_endpoint_info_t) {
 440                         .out_cables = 0x0001,
 441                         .in_cables  = 0x0001
 442                 }
 443         }
 444 },
 445 {
 446         USB_DEVICE(0x0582, 0x001d),
 447         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 448                 .vendor_name = "Roland",
 449                 .product_name = "V-SYNTH",
 450                 .ifnum = 0,
 451                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 452                 .data = & (const snd_usb_midi_endpoint_info_t) {
 453                         .out_cables = 0x0001,
 454                         .in_cables  = 0x0001
 455                 }
 456         }
 457 },
 458 {
 459         USB_DEVICE(0x0582, 0x0023),
 460         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 461                 .vendor_name = "EDIROL",
 462                 .product_name = "UM-550",
 463                 .ifnum = 0,
 464                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 465                 .data = & (const snd_usb_midi_endpoint_info_t) {
 466                         .out_cables = 0x003f,
 467                         .in_cables  = 0x003f
 468                 }
 469         }
 470 },
 471 {
 472         /*
 473          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 474          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 475          * and no MIDI.
 476          */
 477         USB_DEVICE(0x0582, 0x0025),
 478         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 479                 .vendor_name = "EDIROL",
 480                 .product_name = "UA-20",
 481                 .ifnum = QUIRK_ANY_INTERFACE,
 482                 .type = QUIRK_COMPOSITE,
 483                 .data = (const snd_usb_audio_quirk_t[]) {
 484                         {
 485                                 .ifnum = 1,
 486                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 487                         },
 488                         {
 489                                 .ifnum = 2,
 490                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 491                         },
 492                         {
 493                                 .ifnum = 3,
 494                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 495                         },
 496                         {
 497                                 .ifnum = -1
 498                         }
 499                 }
 500         }
 501 },
 502 {
 503         USB_DEVICE(0x0582, 0x0027),
 504         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 505                 .vendor_name = "EDIROL",
 506                 .product_name = "SD-20",
 507                 .ifnum = 0,
 508                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 509                 .data = & (const snd_usb_midi_endpoint_info_t) {
 510                         .out_cables = 0x0003,
 511                         .in_cables  = 0x0007
 512                 }
 513         }
 514 },
 515 {
 516         USB_DEVICE(0x0582, 0x0029),
 517         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 518                 .vendor_name = "EDIROL",
 519                 .product_name = "SD-80",
 520                 .ifnum = 0,
 521                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 522                 .data = & (const snd_usb_midi_endpoint_info_t) {
 523                         .out_cables = 0x000f,
 524                         .in_cables  = 0x000f
 525                 }
 526         }
 527 },
 528 {       /*
 529          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 530          * If the sample format switch is not in an advanced setting, the
 531          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 532          * but offers only 16-bit PCM and no MIDI.
 533          */
 534         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 535         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 536                 .vendor_name = "EDIROL",
 537                 .product_name = "UA-700",
 538                 .ifnum = QUIRK_ANY_INTERFACE,
 539                 .type = QUIRK_COMPOSITE,
 540                 .data = (const snd_usb_audio_quirk_t[]) {
 541                         {
 542                                 .ifnum = 1,
 543                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 544                         },
 545                         {
 546                                 .ifnum = 2,
 547                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 548                         },
 549                         {
 550                                 .ifnum = 3,
 551                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 552                         },
 553                         {
 554                                 .ifnum = -1
 555                         }
 556                 }
 557         }
 558 },
 559 {
 560         USB_DEVICE(0x0582, 0x002d),
 561         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 562                 .vendor_name = "Roland",
 563                 .product_name = "XV-2020",
 564                 .ifnum = 0,
 565                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 566                 .data = & (const snd_usb_midi_endpoint_info_t) {
 567                         .out_cables = 0x0001,
 568                         .in_cables  = 0x0001
 569                 }
 570         }
 571 },
 572 {
 573         USB_DEVICE(0x0582, 0x002f),
 574         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 575                 .vendor_name = "Roland",
 576                 .product_name = "VariOS",
 577                 .ifnum = 0,
 578                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 579                 .data = & (const snd_usb_midi_endpoint_info_t) {
 580                         .out_cables = 0x0007,
 581                         .in_cables  = 0x0007
 582                 }
 583         }
 584 },
 585 {
 586         USB_DEVICE(0x0582, 0x0033),
 587         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 588                 .vendor_name = "EDIROL",
 589                 .product_name = "PCR",
 590                 .ifnum = 0,
 591                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 592                 .data = & (const snd_usb_midi_endpoint_info_t) {
 593                         .out_cables = 0x0003,
 594                         .in_cables  = 0x0007
 595                 }
 596         }
 597 },
 598 {
 599         USB_DEVICE(0x0582, 0x0037),
 600         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 601                 .vendor_name = "Roland",
 602                 .product_name = "Digital Piano",
 603                 .ifnum = 0,
 604                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 605                 .data = & (const snd_usb_midi_endpoint_info_t) {
 606                         .out_cables = 0x0001,
 607                         .in_cables  = 0x0001
 608                 }
 609         }
 610 },
 611 {
 612         /*
 613          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
 614          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
 615          * and no MIDI.
 616          */
 617         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 618         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 619                 .vendor_name = "BOSS",
 620                 .product_name = "GS-10",
 621                 .ifnum = QUIRK_ANY_INTERFACE,
 622                 .type = QUIRK_COMPOSITE,
 623                 .data = & (const snd_usb_audio_quirk_t[]) {
 624                         {
 625                                 .ifnum = 1,
 626                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 627                         },
 628                         {
 629                                 .ifnum = 2,
 630                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 631                         },
 632                         {
 633                                 .ifnum = 3,
 634                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 635                         },
 636                         {
 637                                 .ifnum = -1
 638                         }
 639                 }
 640         }
 641 },
 642 {
 643         USB_DEVICE(0x0582, 0x0040),
 644         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 645                 .vendor_name = "Roland",
 646                 .product_name = "GI-20",
 647                 .ifnum = 0,
 648                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 649                 .data = & (const snd_usb_midi_endpoint_info_t) {
 650                         .out_cables = 0x0001,
 651                         .in_cables  = 0x0001
 652                 }
 653         }
 654 },
 655 {
 656         USB_DEVICE(0x0582, 0x0042),
 657         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 658                 .vendor_name = "Roland",
 659                 .product_name = "RS-70",
 660                 .ifnum = 0,
 661                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 662                 .data = & (const snd_usb_midi_endpoint_info_t) {
 663                         .out_cables = 0x0001,
 664                         .in_cables  = 0x0001
 665                 }
 666         }
 667 },
 668 {
 669         USB_DEVICE(0x0582, 0x0044),
 670         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 671                 .vendor_name = "Roland",
 672                 .product_name = "UA-1000",
 673                 .ifnum = QUIRK_ANY_INTERFACE,
 674                 .type = QUIRK_COMPOSITE,
 675                 .data = (const snd_usb_audio_quirk_t[]) {
 676                         {
 677                                 .ifnum = 1,
 678                                 .type = QUIRK_AUDIO_EDIROL_UA1000
 679                         },
 680                         {
 681                                 .ifnum = 2,
 682                                 .type = QUIRK_AUDIO_EDIROL_UA1000
 683                         },
 684                         {
 685                                 .ifnum = 3,
 686                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 687                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 688                                         .out_cables = 0x0003,
 689                                         .in_cables  = 0x0003
 690                                 }
 691                         },
 692                         {
 693                                 .ifnum = -1
 694                         }
 695                 }
 696         }
 697 },
 698 {
 699         USB_DEVICE(0x0582, 0x0048),
 700         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 701                 .vendor_name = "EDIROL",
 702                 .product_name = "UR-80",
 703                 .ifnum = 0,
 704                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 705                 .data = & (const snd_usb_midi_endpoint_info_t) {
 706                         .out_cables = 0x0003,
 707                         .in_cables  = 0x0007
 708                 }
 709         }
 710 },
 711 {
 712         USB_DEVICE(0x0582, 0x004d),
 713         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 714                 .vendor_name = "EDIROL",
 715                 .product_name = "PCR-A",
 716                 .ifnum = 0,
 717                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 718                 .data = & (const snd_usb_midi_endpoint_info_t) {
 719                         .out_cables = 0x0003,
 720                         .in_cables  = 0x0007
 721                 }
 722         }
 723 },
 724 {
 725         /*
 726          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
 727          * is standard compliant, but has only 16-bit PCM.
 728          */
 729         USB_DEVICE(0x0582, 0x0050),
 730         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 731                 .vendor_name = "EDIROL",
 732                 .product_name = "UA-3FX",
 733                 .ifnum = QUIRK_ANY_INTERFACE,
 734                 .type = QUIRK_COMPOSITE,
 735                 .data = (const snd_usb_audio_quirk_t[]) {
 736                         {
 737                                 .ifnum = 1,
 738                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 739                         },
 740                         {
 741                                 .ifnum = 2,
 742                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 743                         },
 744                         {
 745                                 .ifnum = -1
 746                         }
 747                 }
 748         }
 749 },
 750 {
 751         USB_DEVICE(0x0582, 0x0052),
 752         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 753                 .vendor_name = "EDIROL",
 754                 .product_name = "UM-1SX",
 755                 .ifnum = 0,
 756                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 757         }
 758 },
 759 {
 760         USB_DEVICE(0x0582, 0x0065),
 761         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 762                 .vendor_name = "EDIROL",
 763                 .product_name = "PCR-1",
 764                 .ifnum = 0,
 765                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 766                 .data = & (const snd_usb_midi_endpoint_info_t) {
 767                         .out_cables = 0x0001,
 768                         .in_cables  = 0x0003
 769                 }
 770         }
 771 },
 772 {
 773         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
 774         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 775                 .vendor_name = "Roland",
 776                 .product_name = "SP-606",
 777                 .ifnum = 3,
 778                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 779                 .data = & (const snd_usb_midi_endpoint_info_t) {
 780                         .out_cables = 0x0001,
 781                         .in_cables  = 0x0001
 782                 }
 783         }
 784 },
 785 {
 786         USB_DEVICE(0x0582, 0x006d),
 787         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 788                 .vendor_name = "Roland",
 789                 .product_name = "FANTOM-X",
 790                 .ifnum = 0,
 791                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 792                 .data = & (const snd_usb_midi_endpoint_info_t) {
 793                         .out_cables = 0x0001,
 794                         .in_cables  = 0x0001
 795                 }
 796         }
 797 },
 798 {       /*
 799          * This quirk is for the "Advanced" modes of the Edirol UA-25.
 800          * If the switch is not in an advanced setting, the UA-25 has
 801          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
 802          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
 803          */
 804         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
 805         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 806                 .vendor_name = "EDIROL",
 807                 .product_name = "UA-25",
 808                 .ifnum = QUIRK_ANY_INTERFACE,
 809                 .type = QUIRK_COMPOSITE,
 810                 .data = (const snd_usb_audio_quirk_t[]) {
 811                         {
 812                                 .ifnum = 0,
 813                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 814                         },
 815                         {
 816                                 .ifnum = 1,
 817                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 818                         },
 819                         {
 820                                 .ifnum = 2,
 821                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 822                         },
 823                         {
 824                                 .ifnum = -1
 825                         }
 826                 }
 827         }
 828 },
 829 {
 830         USB_DEVICE(0x0582, 0x0075),
 831         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 832                 .vendor_name = "BOSS",
 833                 .product_name = "DR-880",
 834                 .ifnum = 0,
 835                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 836                 .data = & (const snd_usb_midi_endpoint_info_t) {
 837                         .out_cables = 0x0001,
 838                         .in_cables  = 0x0001
 839                 }
 840         }
 841 },
 842
 843 /* Midiman/M-Audio devices */
 844 {
 845         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
 846         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 847                 .vendor_name = "M-Audio",
 848                 .product_name = "MidiSport 2x2",
 849                 .ifnum = QUIRK_ANY_INTERFACE,
 850                 .type = QUIRK_MIDI_MIDIMAN,
 851                 .data = & (const snd_usb_midi_endpoint_info_t) {
 852                         .out_cables = 0x0003,
 853                         .in_cables  = 0x0003
 854                 }
 855         }
 856 },
 857 {
 858         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
 859         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 860                 .vendor_name = "M-Audio",
 861                 .product_name = "MidiSport 1x1",
 862                 .ifnum = QUIRK_ANY_INTERFACE,
 863                 .type = QUIRK_MIDI_MIDIMAN,
 864                 .data = & (const snd_usb_midi_endpoint_info_t) {
 865                         .out_cables = 0x0001,
 866                         .in_cables  = 0x0001
 867                 }
 868         }
 869 },
 870 {
 871         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
 872         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 873                 .vendor_name = "M-Audio",
 874                 .product_name = "Keystation",
 875                 .ifnum = QUIRK_ANY_INTERFACE,
 876                 .type = QUIRK_MIDI_MIDIMAN,
 877                 .data = & (const snd_usb_midi_endpoint_info_t) {
 878                         .out_cables = 0x0001,
 879                         .in_cables  = 0x0001
 880                 }
 881         }
 882 },
 883 {
 884         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
 885         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 886                 .vendor_name = "M-Audio",
 887                 .product_name = "MidiSport 4x4",
 888                 .ifnum = QUIRK_ANY_INTERFACE,
 889                 .type = QUIRK_MIDI_MIDIMAN,
 890                 .data = & (const snd_usb_midi_endpoint_info_t) {
 891                         .out_cables = 0x000f,
 892                         .in_cables  = 0x000f
 893                 }
 894         }
 895 },
 896 {
 897         /*
 898          * For hardware revision 1.05; in the later revisions (1.10 and
 899          * 1.21), 0x1031 is the ID for the device without firmware.
 900          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
 901          */
 902         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
 903         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 904                 .vendor_name = "M-Audio",
 905                 .product_name = "MidiSport 8x8",
 906                 .ifnum = QUIRK_ANY_INTERFACE,
 907                 .type = QUIRK_MIDI_MIDIMAN,
 908                 .data = & (const snd_usb_midi_endpoint_info_t) {
 909                         .out_cables = 0x01ff,
 910                         .in_cables  = 0x01ff
 911                 }
 912         }
 913 },
 914 {
 915         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
 916         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 917                 .vendor_name = "M-Audio",
 918                 .product_name = "MidiSport 8x8",
 919                 .ifnum = QUIRK_ANY_INTERFACE,
 920                 .type = QUIRK_MIDI_MIDIMAN,
 921                 .data = & (const snd_usb_midi_endpoint_info_t) {
 922                         .out_cables = 0x01ff,
 923                         .in_cables  = 0x01ff
 924                 }
 925         }
 926 },
 927 {
 928         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
 929         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 930                 .vendor_name = "M-Audio",
 931                 .product_name = "MidiSport 2x4",
 932                 .ifnum = QUIRK_ANY_INTERFACE,
 933                 .type = QUIRK_MIDI_MIDIMAN,
 934                 .data = & (const snd_usb_midi_endpoint_info_t) {
 935                         .out_cables = 0x000f,
 936                         .in_cables  = 0x0003
 937                 }
 938         }
 939 },
 940 {
 941         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
 942         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 943                 .vendor_name = "M-Audio",
 944                 .product_name = "Quattro",
 945                 .ifnum = QUIRK_ANY_INTERFACE,
 946                 .type = QUIRK_COMPOSITE,
 947                 .data = & (const snd_usb_audio_quirk_t[]) {
 948                         /*
 949                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
 950                          * and share endpoints with the other interfaces.
 951                          * Ignore them.  The other interfaces can do 24 bits,
 952                          * but captured samples are big-endian (see usbaudio.c).
 953                          */
 954                         {
 955                                 .ifnum = 0,
 956                                 .type = QUIRK_IGNORE_INTERFACE
 957                         },
 958                         {
 959                                 .ifnum = 1,
 960                                 .type = QUIRK_IGNORE_INTERFACE
 961                         },
 962                         {
 963                                 .ifnum = 2,
 964                                 .type = QUIRK_IGNORE_INTERFACE
 965                         },
 966                         {
 967                                 .ifnum = 3,
 968                                 .type = QUIRK_IGNORE_INTERFACE
 969                         },
 970                         {
 971                                 .ifnum = 4,
 972                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 973                         },
 974                         {
 975                                 .ifnum = 5,
 976                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 977                         },
 978                         {
 979                                 .ifnum = 6,
 980                                 .type = QUIRK_IGNORE_INTERFACE
 981                         },
 982                         {
 983                                 .ifnum = 7,
 984                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 985                         },
 986                         {
 987                                 .ifnum = 8,
 988                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 989                         },
 990                         {
 991                                 .ifnum = 9,
 992                                 .type = QUIRK_MIDI_MIDIMAN,
 993                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 994                                         .out_cables = 0x0001,
 995                                         .in_cables  = 0x0001
 996                                 }
 997                         },
 998                         {
 999                                 .ifnum = -1
1000                         }
1001                 }
1002         }
1003 },
1004 {
1005         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1006         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1007                 .vendor_name = "M-Audio",
1008                 .product_name = "AudioPhile",
1009                 .ifnum = 6,
1010                 .type = QUIRK_MIDI_MIDIMAN,
1011                 .data = & (const snd_usb_midi_endpoint_info_t) {
1012                         .out_cables = 0x0001,
1013                         .in_cables  = 0x0001
1014                 }
1015         }
1016 },
1017 {
1018         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1019         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1020                 .vendor_name = "M-Audio",
1021                 .product_name = "Ozone",
1022                 .ifnum = 3,
1023                 .type = QUIRK_MIDI_MIDIMAN,
1024                 .data = & (const snd_usb_midi_endpoint_info_t) {
1025                         .out_cables = 0x0001,
1026                         .in_cables  = 0x0001
1027                 }
1028         }
1029 },
1030 {
1031         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1032         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1033                 .vendor_name = "M-Audio",
1034                 .product_name = "OmniStudio",
1035                 .ifnum = QUIRK_ANY_INTERFACE,
1036                 .type = QUIRK_COMPOSITE,
1037                 .data = & (const snd_usb_audio_quirk_t[]) {
1038                         {
1039                                 .ifnum = 0,
1040                                 .type = QUIRK_IGNORE_INTERFACE
1041                         },
1042                         {
1043                                 .ifnum = 1,
1044                                 .type = QUIRK_IGNORE_INTERFACE
1045                         },
1046                         {
1047                                 .ifnum = 2,
1048                                 .type = QUIRK_IGNORE_INTERFACE
1049                         },
1050                         {
1051                                 .ifnum = 3,
1052                                 .type = QUIRK_IGNORE_INTERFACE
1053                         },
1054                         {
1055                                 .ifnum = 4,
1056                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1057                         },
1058                         {
1059                                 .ifnum = 5,
1060                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1061                         },
1062                         {
1063                                 .ifnum = 6,
1064                                 .type = QUIRK_IGNORE_INTERFACE
1065                         },
1066                         {
1067                                 .ifnum = 7,
1068                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1069                         },
1070                         {
1071                                 .ifnum = 8,
1072                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1073                         },
1074                         {
1075                                 .ifnum = 9,
1076                                 .type = QUIRK_MIDI_MIDIMAN,
1077                                 .data = & (const snd_usb_midi_endpoint_info_t) {
1078                                         .out_cables = 0x0001,
1079                                         .in_cables  = 0x0001
1080                                 }
1081                         },
1082                         {
1083                                 .ifnum = -1
1084                         }
1085                 }
1086         }
1087 },
1088
1089 /* Mark of the Unicorn devices */
1090 {
1091         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1092         USB_DEVICE(0x07fd, 0x0001),
1093         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1094                 .vendor_name = "MOTU",
1095                 .product_name = "Fastlane",
1096                 .ifnum = QUIRK_ANY_INTERFACE,
1097                 .type = QUIRK_COMPOSITE,
1098                 .data = & (const snd_usb_audio_quirk_t[]) {
1099                         {
1100                                 .ifnum = 0,
1101                                 .type = QUIRK_MIDI_MOTU
1102                         },
1103                         {
1104                                 .ifnum = 1,
1105                                 .type = QUIRK_IGNORE_INTERFACE
1106                         },
1107                         {
1108                                 .ifnum = -1
1109                         }
1110                 }
1111         }
1112 },
1113
1114 {
1115         /* Creative Sound Blaster MP3+ */
1116         USB_DEVICE(0x041e, 0x3010),
1117         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1118                 .vendor_name = "Creative Labs",
1119                 .product_name = "Sound Blaster MP3+",
1120                 .ifnum = QUIRK_NO_INTERFACE
1121         }
1122
1123 },
1124
1125 /* Emagic devices */
1126 {
1127         USB_DEVICE(0x086a, 0x0001),
1128         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1129                 .vendor_name = "Emagic",
1130                 /* .product_name = "Unitor8", */
1131                 .ifnum = 2,
1132                 .type = QUIRK_MIDI_EMAGIC,
1133                 .data = & (const snd_usb_midi_endpoint_info_t) {
1134                         .out_cables = 0x80ff,
1135                         .in_cables  = 0x80ff
1136                 }
1137         }
1138 },
1139 {
1140         USB_DEVICE(0x086a, 0x0002),
1141         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1142                 .vendor_name = "Emagic",
1143                 /* .product_name = "AMT8", */
1144                 .ifnum = 2,
1145                 .type = QUIRK_MIDI_EMAGIC,
1146                 .data = & (const snd_usb_midi_endpoint_info_t) {
1147                         .out_cables = 0x80ff,
1148                         .in_cables  = 0x80ff
1149                 }
1150         }
1151 },
1152 {
1153         USB_DEVICE(0x086a, 0x0003),
1154         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1155                 .vendor_name = "Emagic",
1156                 /* .product_name = "MT4", */
1157                 .ifnum = 2,
1158                 .type = QUIRK_MIDI_EMAGIC,
1159                 .data = & (const snd_usb_midi_endpoint_info_t) {
1160                         .out_cables = 0x800f,
1161                         .in_cables  = 0x8003
1162                 }
1163         }
1164 },
1165
1166 {
1167         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1168         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1169                 .vendor_name = "Terratec",
1170                 .product_name = "PHASE 26",
1171                 .ifnum = 3,
1172                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1173         }
1174 },
1175
1176 /* Novation EMS devices */
1177 {
1178         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1179         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1180                 .vendor_name = "Novation",
1181                 .product_name = "ReMOTE Audio/XStation",
1182                 .ifnum = 4,
1183                 .type = QUIRK_MIDI_NOVATION
1184         }
1185 },
1186 {
1187         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1188         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1189                 .vendor_name = "Novation",
1190                 .product_name = "Speedio",
1191                 .ifnum = 3,
1192                 .type = QUIRK_MIDI_NOVATION
1193         }
1194 },
1195 {
1196         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1197         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1198                 .vendor_name = "Novation",
1199                 .product_name = "ReMOTE25",
1200                 .ifnum = 0,
1201                 .type = QUIRK_MIDI_NOVATION
1202         }
1203 },
1204
1205 {
1206         /*
1207          * Some USB MIDI devices don't have an audio control interface,
1208          * so we have to grab MIDI streaming interfaces here.
1209          */
1210         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1211                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1212         .bInterfaceClass = USB_CLASS_AUDIO,
1213         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1214         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
1215                 .ifnum = QUIRK_ANY_INTERFACE,
1216                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1217         }
1218 },
1219
1220 #undef USB_DEVICE_VENDOR_SPEC