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