sound/usb/usbquirks.h

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