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